深入理解Javascript中构造函数和原型对象的区别（转存）

Object是构造函数，而Object.prototype是构造函数的原型对象。构造函数自身的属性和方法无法被共享，而原型对象的属性和方法可以被所有实例对象所共享。

　　首先，我们知道，构造函数是生成对象的模板，一个构造函数可以生成多个对象，每个对象都有相同的结构。构造函数的缺点就是，每当你实例化两个对象时，需要调用两次构造函数的某一个方法，这带来的坏处就是占用内存，而且没必要。

　　其次，为了解决构造函数的属性和方法无法被对象实例所共享的问题，我们可以把需要共享的属性和方法放在原型（prototype）对象上。原型对象上的所有属性和方法，都会被对象实例所共享。对于构造函数来说，prototype是作为构造函数的属性；对于对象实例来说，prototype是对象实例的原型对象。所以prototype即是属性，又是对象。

　　然后，除了undefined和null之外，每一个数据类型都可以看成一个对象，每一个对象都有它的原型。所有一切对象的原型顶端，都是Object.prototype，即Object构造函数的prototype属性指向的那个对象。当然，Object.prototype对象也有自己的原型对象，那就是没有任何属性和方法的null对象，而null对象没有自己的原型。

　　原型链的特点有：

　　a：读取对象的某个属性时，JavaScript引擎先寻找对象本身的属性，如果找不到，就到它的原型去找，如果还是找不到，就到原型的原型去找。如果直到最顶层的Object.prototype还是找不到，则返回undefined。

　　b：如果对象自身和它的原型，都定义了一个同名属性，那么优先读取对象自身的属性，这叫做“覆盖”（overiding）。

　　c：一级级向上在原型链寻找某个属性，对性能是有影响的。所寻找的属性在越上层的原型对象，对性能的影响越大。如果寻找某个不存在的属性，将会遍历整个原型链。

　　再次，constructor属性是原型对象上的一个属性，可以被所有实例对象所共享。要注意的是，prototype是构造函数的属性，而constructor则是构造函数的prototype属性所指向的那个对象，也就是原型对象的属性。由于constructor属性是一种原型对象和构造函数的关系，所以在修改原型对象的时候，一定要注意constructor的指向问题。

　　最后，instanceof运算符返回一个布尔值，用于判断对象是否为某个构造函数的实例。

　　在接下来的分享中，会谈谈Object的部分方法和Object.prototoype的部分方法。虽然都是概念性问题，但是如果理解了这些概念，对于MVVM框架和各种js框架的理解都有相当大的帮助。

　　以下的分享会分为如下内容：

　　1.Object和Object.prototype的区别

　　2.Object.getPrototypeOf()

　　3.Object.setPrototypeOf()

　　4.Object.create()

　　5.Object.prototype.isPrototypeOf()

　　6.Object.prototype.__proto__

1.Object和Object.prototype的区别

　　个人认为，要学好javascript的其中一个方法就是，必须理解每一个" . "所代表的意思是什么，是调用自身的属性和方法呢，还是继承原型的对象的属性和方法。来看看Object构造函数和构造函数的原型Object.prototype都有哪些属性和方法。

　　Object是构造函数，而Object.prototype是构造函数的原型对象。构造函数自身的属性和方法无法被共享，而原型对象的属性和方法可以被所有实例对象所共享。

Object的属性和方法：

aaarticlea/png;base64,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" alt="" />

Object.prototype的属性和方法：

aaarticlea/png;base64,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" alt="" />

　　上面例子中，Object拥有自己的方法prototype，getPrototypeOf()，setPrototypeOf()等，这些方法无法被实例所共享。而Object.prototypeOf()的hasOwnProperty，isPrototypeOf()，constructor等属性和方法是可以被实例对象所共享的。举一个最简单的例子。

1     function Keith() {}
2     var a = new Keith();
3     console.log(a.prototype);    //undefined
4     console.log(a.constructor);    //Keith()

　　上面代码中，构造函数Keith是没有任何属性和方法的。当访问prototype属性时返回undefined，是因为prototype属性没有办法从构造函数中继承，只能由构造函数本身访问。而constructor返回了Keith()，因为constructor属性本身就是Object.prototype中的属性，可以被所有实例对象所共享。

　　那么问题来了，如何知道实例对象的原型呢？可以通过Object.isPrototypeOf方法和继承原型对象的isPrototypeOf方法实现。

1     console.log(Keith.prototype.isPrototypeOf(a));    //true
2     console.log(Object.getPrototypeOf(a) === Keith.prototype) //true

　　上面代码中，实例对象a的原型就是Keith.prototype。这两个属性会稍后介绍。

2.Object.getPrototypeOf()

　　Object.getPrototypeOf方法返回一个对象的原型。这是获取原型对象的标准方法。

 1     // 空对象的原型是Object.prototype
 2     console.log(Object.getPrototypeOf({}) === Object.prototype) // true
 3
 4     // 函数的原型Function.prototype
 5     function keith() {}
 6     console.log(Object.getPrototypeOf(keith) === Function.prototype)     //true
 7
 8     // 数组的原型Array.prototype
 9     var arr = [1,2,3];
10     console.log(Object.getPrototypeOf(arr) === Array.prototype) ///true

　　

3.Object.setPrototypeOf()

　　Object.setPrototypeOf方法可以为现有对象设置原型，然后返回一个新对象。这个可以接收两个参数，第一个是现有对象，第二个是原型对象。

 1     var keith = {
 2         height: 180
 3     };
 4     var rascal = Object.setPrototypeOf({}, keith);
 5     console.log(rascal.height);    //180
 6
 7     //上下两个代码片段相同。
 8     var keith = {
 9         height: 180
10     };
11     var rascal ={
12         __proto__: keith
13     };
14     console.log(rascal.height);    //180

　　上面代码中，rascal对象是Object.setPrototypeOf方法返回的一个新对象。该对象本身为空、原型为keith对象，所以rascal对象可以拿到keith对象的所有属性和方法。rascal对象本身并没有height属性，但是JavaScript引擎找到它的原型对象keith，然后读取keith的height属性。

4.Object.create()

　　Object.create方法用于从原型对象生成新的对象实例，可以代替new命令。它接受一个参数，这个参数为所要继承的原型对象，然后返回一个实例对象。

1     var Keith = {
2         hobby : function() {
3             return 'Watching Movies';
4         }
5     };
6
7     var rascal = Object.create(Keith);
8     console.log(rascal.hobby())    //'Watching Movies'

　　上面代码中，Object.create方法将Keith对象作为rascal的原型对象，此时rascal就继承了Keith对象中的所有属性和方法。rascal就成为了Keith对象的实例对象。用下面这段代码比较好理解。

1     function Keith() {};
2     Keith.prototype.hobby = function() {
3         return 'Watching Movies';
4     }
5
6     var rascal = Object.create(Keith);
7     console.log(rascal.hobby())    //'Watching Movies';

　　new操作符和Object.create方法都是返回一个对象实例，但是两者有一些区别。

1     function Keith() {}
2     var a = new Keith();
3     var b = Object.create(Keith.prototype);
4
5     console.log(a instanceof Keith);    //true
6     console.log(b instanceof Keith);    //true

　　上面代码中，可以使用new操作符来调用构造函数，返回对象实例；而Object.create传入的参数必须是构造函数Keith的原型。

　　实际上，如果有老式浏览器不支持Object.create方法，可以用下面这段代码来构造一个Object.create方法。

1     if (typeof Object.create !=='function') {
2         Object.create = function(x) {
3             function F() {};
4             F.prototype = x;
5             return new F();
6         };
7     }

　　下面这三种方式生成的实例对象都是等价的。

1     var o1 = Object.create({});
2     var o2 = Object.create(Object.prototype);
3     var o2 = new Object();

　　在使用Object.create方法时，要注意的是必须传入原型对象，否则会报错。

1     var o1 = Object.create();
2     console.log(o1);//TypeError: Object.create requires more than 0 arguments

　　Object.create方法生成的对象实例，动态继承了原型对象。也就是说，修改原型对象的属性和方法会反应在对象实例上。

1     var keith = {
2         height:180
3     };
4
5     var rascal = Object.create(keith);
6     keith.height=153;
7     console.log(rascal.height)    //153

　　上面代码中，修改原型对象，会影响生成的对象实例。

　　Object.create方法生成的对象，继承了它的原型对象的构造函数。

1     function Keith() {};
2     var boy = new Keith();
3     var girl = Object.create(boy);
4     console.log(Object.getPrototypeOf(girl) === boy); //true
5     console.log(girl.constructor === Keith);    //true
6     console.log(girl instanceof Keith);    //true

　　上面代码中，girl对象的原型是boy对象，girl对象的constructor属性指向了原型对象boy的构造函数Keith。

5.Object.prototype.isPrototypeOf()

　　对象实例的isPrototypeOf方法，用于判断一个对象对象是否是另外一个对象的原型。

1     var o1 = {};
2     var o2 = Object.create(o1);
3     var o3 = Object.create(o2);
4
5     console.log(o1.isPrototypeOf(o2)); //true
6     console.log(o2.isPrototypeOf(o3)); //true
7     console.log(o1.isPrototypeOf(o3)); //true

　　上面代码中，可以看出，只要某个对象处于原型链上，isPrototypeOf都返回true。

1     function Keith() {};
2
3     console.log(Function.prototype.isPrototypeOf(Keith));    //true
4     console.log(Object.prototype.isPrototypeOf(Function));    //true
5     console.log(Object.getPrototypeOf(Object.prototype) === null); //true

　　上面代码中，构造函数Keith的原型指向了Function.prototype，而构造函数Function的原型指向了Object.prototype。Object的原型指向了没有任何属性和方法的null对象。

6.Object.prototype.__proto__

　　__proto__属性（前后两条下划线）可以改写某个对象的原型对象。这个属于实例方法。

1     var keith = {};
2     var rascal = {};
3     rascal.__proto__ = keith;
4     console.log(keith.isPrototypeOf(rascal));    //true

　　上面代码中，通过rascal对象的__proto__属性，将rascal的原型指向了keith对象。

　　__proto__属性只有浏览器才需要部署，其他环境可以没有这个属性，而且前后的两根下划线，表示它本质是一个内部属性，不应该对使用者暴露。因此，应该尽量少用这个属性，而是用Object.getPrototypeof()（读取）和Object.setPrototypeOf()（设置），进行原型对象的读写操作。

　　来做一个小小的总结，上面对一些属性和方法的介绍都可以归结为一句话：

　　构造函数本身的属性无法被对象实例共享，而原型对象上的属性和方法可以被所用对象实例所共享。