JavaScript面向对象二

一、理解篇:

1、每创建的一个函数都有一个prototype属性，该属性是一个对象，prototype默认有一个constructor属性，默认指向prototype对象所在函数的指针；
2、prototype对象中定义的属性和方法是实例化prototype所在函数对象所共享的，当prototype为字面量对象时，其constructor属性将指向Object构造函数；
3、在实例对象中默认有一个内部属性__proto__，该属性指向原型对象，即(构造函数中的prototype属性，实例对象的原型对象)
4、在一个函数被作为构造函数时，我们把在构造函数中定义的属性，方法称为实例属性和方法，把在prototype对象中定义的属性和方法，称为原型属性和方法；

二、属性篇：

isPrototypeOf:    检查某对象是否是另一对象的原型
hasOwnProperty:   检测一个属性是否存在于实例中
in:               只要属性能够被实例所访问，就返回true，无论属性是否存在原型还是实例中
for-in:           通过for循环，返回所有可以枚举的属性(在ie6中存在一个bug，即被打上[[DontEnum]]不可枚举的标签属性不会被返回，而其他浏览器则屏蔽了不可枚举的属性，即也会被返回)

三、模式篇：

1、工厂模式

function obj(arg1,arg2){
var o = new Object();
o.arg1 = arg1;
o.arg2 = arg2;
o.method = function(){
console.log(arg1+arg2);
}
return o;
}
var obj1 = obj(10,20);
obj1.method();	//30

缺点：对象不识别类型

2、构造函数模式

function Obj(arg1,arg2){
this.arg1 = arg1;
this.arg2 = arg2;
this.method = function(){
console.log(arg1+arg2);
}
}
var obj1 = new Obj(10,20);
obj1.method();	//30

缺点：方法不能重用

3、原型模式

function Obj(){}
Obj.prototype = {
constructor: Obj,
arg3: ["a","b","c"],
method: function(){
console.log(this.arg3.toString());
}
}
var obj1 = new Obj();
obj1.method();	//a,b,c
var obj2 = new Obj();
obj2.arg3.push("d");
obj1.method();	//a,b,c,d

缺点：原型对象存在引用类型属性时，此属性在实例对象上的修改会影响到另一个实例的共享属性

4、组合使用构造函数模式和原型模式

function Obj(arg1,arg2){
this.arg1 = arg1;
this.arg2 = arg2;
this.arg3 = ["a","b","c"];
}
Obj.prototype = {
constructor: Obj,
method: function(){
console.log(this.arg1+this.arg2);
}
}
var obj1 = new Obj(10,20);
obj1.method();  //30
var obj2 = new Obj();
obj2.arg3.push("d");
console.log(obj1.arg3.toString());	//a,b,c

优点：在不涉及继承时，此模式为最佳模式

5、动态原型模式

function Obj(arg1,arg2){
this.arg1 = arg1;
this.arg2 = arg2;
if(typeof this.method != "function"){
Obj.prototype.method = function(){
console.log(this.arg1+this.arg2);
}
}
}
var obj1 = new Obj(10,20);
obj1.method();  //30

缺点：在实例化对象后不能再重写原型，否则会切断现有原型与实例的关系

6、寄生构造函数模式

function Obj(arg1,arg2){
var o = new Object();
o.arg1 = arg1;
o.arg2 = arg2;
o.method = function(){
console.log(this.arg1+this.arg2);
}
return o;
}
var obj1 = new Obj(10,20);
obj1.method();  //30

缺点：与工厂模式类似，不建议使用该模式

7、稳妥构造函数模式

function Obj(arg1){
var o = new Object();
o.method = function(){
console.log(arg1);
}
return o;
}
var obj1 = Obj(10);
obj1.method();	//10

说明：此模式只能通过method方法才能访问arg1变量，即：目的是为了在安全环境中执行

8、原型链

function Super(arg1,arg2){
this.arg1 = arg1;
this.arg2 = arg2;
this.arg3 = ["a","b","c"];
}
Super.prototype = {
constructor: Super,
superMethod: function(){
console.log(this.arg3.toString());
}
}
function Sub(){

}
Sub.prototype = new Super();
Sub.prototype.constructor = Sub;

var obj1 = new Sub();
obj1.superMethod();  //a,b,c
var obj2 = new Sub();
obj2.arg3.push("d");
obj1.superMethod();  //a,b,c,d

缺点：只要是原型对象中存在引用类型属性，那么就会出现单独使用原型模式遇到的问题

9、借用构造函数

function Super(){
this.arg3 = ["a","b","c"];
}
function Sub(){
Super.call(this);
}
var superObj = new Super();
superObj.arg3.push("d");
var obj1 = new Sub();
console.log(obj1.arg3.toString());	//a,b,c

说明：在一个构造函数中调用另一个构造函数，即：在一个作用域中执行另一个作用域中要执行的代码

10、组合继承

function Super(arg1,arg2){
this.arg1 = arg1;
this.arg2 = arg2;
this.arg3 = ["a","b","c"];
}
Super.prototype = {
constructor: Super,
superMethod: function(){
console.log(this.arg3.toString());
}
}
function Sub(){
Super.call(this,10,20);  //在实例化对象时，此句会调用超类构造函数
}
Sub.prototype = new Super();  //第一次调用超类构造函数
var obj1 = new Sub();
obj1.superMethod();	 //a,b,c
var obj2 = new Sub();  //第二次调用超类构造函数
obj2.arg3.push("d");
obj1.superMethod();	 //a,b,c

说明：此模式是继承原型链与借用构造函数模式中的优点，但也有缺点，即：在每次实例化子类对象时，都会调用两次超类构造函数

11、原型式继承

function object(o){
function F(){}
F.prototype = o;
return new F();
}
var o = {
arg1: 10,
method: function(){
console.log(this.arg1);
}
}
var obj1 = object(o);
obj1.method();

说明：注意object函数返回的是以对象o为原型对象的实例对象

12、寄生式继承

function object(o){
function F(){}
F.prototype = o;
return new F();
}
var o = {
arg1: 10,
method: function(){
console.log(this.arg1);
}
}
function createAnother(original){
var clone = object(original);
clone.sayHi = function(){
alert("hi");
}
return clone;
}
var obj1 = createAnother(o);
obj1.sayHi();	//hi

说明：与原型式继承模式类似，只不过在返回的实例对象上增加了行为

13、寄生组合式继承

function object(o){
function F(){}
F.prototype = o;
return new F();
}
function inheritPrototype(subType,superType){
var prototype = object(superType.prototype);	//获得以superType.prototype为原型对象的临时对象，因此临时对象拥有这个原型对象的所有属性和方法
prototype.constructor = subType;				//为prototype这个临时对象初始化constructor属性值
subType.prototype = prototype;					//将子类的prototype赋值为这个临时对象，因此子类的实例化对象共享这个临时对象(即：也共享超类构造函数中的prototype属性)中的所有属性和方法
}
function Super(arg1,arg2){
this.arg1 = arg1;
this.arg2 = arg2;
}
Super.prototype = {
constructor: Super,
superMethod: function(){
console.log(this.arg1+this.arg2);
}
}
function Sub(arg1,arg2){
Super.call(this,arg1,arg2);
}
inheritPrototype(Sub,Super);
var obj1 = new Sub(10,20);
obj1.superMethod();	 //30
console.log(obj1.constructor);	//Sub(arg1,arg2){ xxx }

var superObj = new Super();
console.log(superObj.constructor);	//Super(arg1,arg2){ xxx }

说明：此模式是继承组合式继承和寄生式继承的优点，该模式为最佳模式

14、jQuery核心框架

var $ = Fn = jQuery = function(){
return new Fn.prototype.init();
}
Fn.prototype = jQuery.prototype = {
init: function(){
return this;
},
method1: function(){
console.log("method1");
},
method2: function(){
console.log("method2");
}
}
Fn.prototype.init.prototype = Fn.prototype;

说明：
以上代码不是上面任何模式中的一种，也没有涉及到选择器，只是模拟jQuery核心框架代码，该代码中涉及到函数返回值，原型对象以及继承。
首先，jQuery指定的函数中返回一个实例化对象，这个返回的实例化对象是以jQuery函数中的原型属性中的init方法作为构造函数，init方法返回this，
此this并不会污染上一级作用域，因为它指向的是实例化init构造函数的对象，即jQuery函数中返回的对象；
将init方法的原型属性赋值为jQuery函数的原型属性，那么jQuery函数的返回对象就会共享jQuery函数的原型属性中的属性和方法。

使用方法：

var obj = $();
obj.method1();	//method1

[注：此文章是总结JavaScript高级程序设计第二版中第六章面向对象]