javascript构造函数和原型对象

首先明确一点，标准和实现是两个概念。ECMAScript是标准，而不同浏览器厂商（vendor）可以根据此标准有不同的实现，这也是客户端浏览器兼容性问题的原因之一。

__proto__与 prototype

在标准中，几乎每个对象都有一个[[prototype]]属性，且该属性为隐藏属性，并不对外暴露，指向这个对象的原型（即obj.prototype）。

但为了访问需要，很多浏览器给对象提供了__proto__这一属性，用以访问上面提到的[[prototype]]，因为浏览器实现并不一致，不建议直接使用__proto__。好在ES5（ECMAScript5.1版本）中增加了Object.getPrototypeOf()方法，用于获得一个对象的[[prototype]]，可用于替代__proto__。ES6中，则增加Object.setPrototypeOf()，可直接修改一个对象的[[prototype]]。

那问题来了，我们常说的prototype是什么呢？

 //构造函数的prototype
 console.log(Object.prototype);   //Object {}
 console.log(Array.prototype);    //[Symbol(Symbol.unscopables): Object]
 console.log(Function.prototype); //function () {}
 console.log(Number.prototype);   //Number {[[PrimitiveValue]]: 0}
 console.log(RegExp.prototype);   //Object {}
 console.log(String.prototype);   //String {length: 0, [[PrimitiveValue]]: ""}
 console.log(Boolean.prototype);  //Boolean {[[PrimitiveValue]]: false}
 //实例的prototype
 console.log(({name: 'yunmo'}).prototype);  //undefined
 console.log(([1,2]).prototype);   //undefined
 console.log((function(){}).prototype);   //Object {}
 console.log((1).prototype);  //undefined
 console.log(('yunmo').prototype);   //undefined
 console.log((true).prototype);    //undefined
 //实例的__proto__
 console.log(({name: 'yunmo'}).__proto__);  //Object {}
 console.log(([1,2]).__proto__);   //[Symbol(Symbol.unscopables): Object]
 console.log((function(){}).__proto__);   //function () {}
 console.log((1).__proto__);  //Number {[[PrimitiveValue]]: 0}
 console.log(('yunmo').__proto__);   //String {length: 0, [[PrimitiveValue]]: ""}
 console.log((true).__proto__);    //Boolean {[[PrimitiveValue]]: false}

如上代码可以看出：

除了函数以外，实例对象是没有prototype属性的。只有函数才有prototype属性。实例对象通过__proto__属性（[[prototype]]）串起一个原型链，以此在原型链上查找属性。即一个对象具有属性__proto__，称为隐式原型，该原型指向构造该对象的构造函数的原型，这保证了实例能够访问在构造函数原型中定义的属性和方法。

每个函数都有一个属性prototype。prototype的属性值是一个对象，即属性的集合，默认只有一个constructor属性，指向这个函数本身。

如下图：Super是一个构造函数，右侧的方框就是它的原型。

constructor and prototype

function Yunmo() {
    console.log('I AM YUNMO');
}
var yunmo = new Yunmo();
console.log(yunmo.constructor === Yunmo);  //true 

原型作为对象，不只拥有默认的constructor属性，还允许自定义属性。如Object构造函数的prototype上，拥有几个我们熟悉的属性。

Object.prototype

一般来说有以下等式：

obj.__proto__ === obj.constructor.prototype

如果一个对象obj是通过Object.create函数构造出来的，那么obj.__proto__就不一定是obj.constructor.prototype。

var presetObject = {
    name: 'yun',
    age: 18
};
presetObject.prototype = Object.prototype;
var yunmo = Object.create(presetObject);
console.log(yunmo.__proto__ === yunmo.constructor.prototype);  //false

constructor和prototype

看一下官方定义：

constructor

The value of a constructor's prototype property is a prototype object that is used to implement inheritance and shared properties.

prototype

object that provides shared properties for other objects
When a constructor creates an object, that object implicitly references the constructor's prototype property for the purpose of resolving property references.
Alternatively, a new object may be created with an explicitly specified prototype by using the Object.create built-in function.

译：构造函数的原型的值是个原型对象，用来实现继承和属性共享。
原型是用来为其他对象提供共享属性的对象。
当构造函数创建了一个对象，该对象将隐性地引用构造函数原型属性，为了解决属性引用问题。
或者，还可以通过内置的Object.create函数，指定一个明确的原型来创建一个新的对象。

简单来说：prototype使得我们有能力向对象添加属性和方法。

var Coder = function (name, age) {
    this.name = name;
    this.age = age;
    this.learnCoding = function () {
        console.log(this.name + ' is learning coding while he is ' + this.age);
    }
};
var yun = new Coder('yun', 18);
var mo = new Coder('mo', 12);
yun.learnCoding();
mo.learnCoding();
console.log(yun.learnCoding === mo.learnCoding);   //false

如上：一个构造函数Yun生成了yun和mo两个实例对象，分别拥有name、age属性和learnCoding方法。然而yun.learnCoding ！== mo.learnCoding，说明每次通过new实例化一个对象的时候，都会去创建一个learnCoding方法。但是learnCoding方法做的其实是同样的事情，却不能被两个实例所共享，就造成了内存资源的浪费。

为了避免上述问题，我们需要借助构造函数的原型对象来实现继承和属性共享。这时候，prototype就相当于一个公共容器，存放一些公用的东西。

var Coder = function (name, age) {
    this.name = name;
    this.age = age;
};
Coder.prototype.learnCoding = function () {
    console.log(this.name + ' is learning coding while he is ' + this.age);
};
var yun = new Coder('yun', 18);
var mo = new Coder('mo', 12);
yun.learnCoding();
mo.learnCoding();
console.log(yun.learnCoding === mo.learnCoding);   //true

原型链

对象在调用一个方法时会先在自身寻找是否有该方法，若没有，则通过内部的__proto__属性去自己的构造函数原型上寻找，如果还找不到，继续向上追溯，直到Object.prototype.__proto__ = null为止，这种依靠原型查找形成的查询链条，即原型链。

原型链的查找是根据什么进行的？prototype？__proto__？还是constructor?

理论上来说，谁都不是。因为prototype、__proto__ 和constructor这三个属性是由js引擎对外暴露的API。如本文一开始所说的，对象内部存在一个隐藏属性[[prototype]]，外部是无法直接访问的，js引擎通过提供__proto__属性使得代码上能够访问[[prototype]]。因此，从实际可操作的层面来说，是根据__proto__属性进行查找的。