［原创］更自然的理解 JS 中的构造函数&原型链

格式更好看的在 Github,https://github.com/temberature/blog/issues/10

首先最简单的：

var o = new Object(); Object.prototype === o.__proo__; //true o.cOnstructor=== Object; //true o.hasOwnProperty('constructor'); //false 

构造函数和原型对象之间是相互指向的。 因为没办法修改 Object 构造函数，所以只能通过字面量完成初始化过程。

var o = { a: 0 } 

如果是初始化参数是变量呢？

var a = b ? 0 : 1; var o = { a: a } 

封装一下

function O (b) { var a = b ? 0 : 1; return { a: a } } var o = O(1); // var o =new O(1); o.cOnstructor=== O; //false o instanceof O; //false o.__proto__ === O.prototype; //false 

这又被称为工厂模式。 如果出现了局部变量，

function O (b) { var c = 2; var a = (b + c) ? 0 : 1; return { a: a, sayC: function () { alert(c); } } } var o = O(1); 

这又被称为稳妥构造函数。 如果是自定义的构造函数又是怎么样的呢？

function F () {} var f = new F(); F.prototype === f.__proto__; //true f.cOnstructor=== F; //true f.hasOwnProperty('constructor'); //false F.prototype.cOnstructor=== F; //true f instanceof F; //true 

如果换种写法

function F () {} F.prototype = new Object(); var f = new F(); F.prototype === f.__proto__; //true f.cOnstructor=== F; //false f.hasOwnProperty('constructor'); //false F.prototype.cOnstructor=== F; //false f instanceof F; //true 

虽然 instanceof 操作符结果没问题（就是判断两者的原型指向是否相等），但是原型对象没有指向构造函数。

function F () {} F.prototype = new Object(); F.prototype.cOnstructor= F; var f = new F(); F.prototype === f.__proto__; //true f.cOnstructor=== F; //true f.hasOwnProperty('constructor'); //false F.prototype.cOnstructor=== F; //true f instanceof F; //true 

这被称为组合模式 如果把原型定义放在构造函数内

function F () { if (this.constructor !== F) { F.prototype = { constructor: F } } } 

这又叫做动态原型。 如果把原型对象换成变量，再封装一下

function create (o) { function F () {} F.prototype = o; return new F(); } var f = create(new Object()); f.cOnstructor=== Object; //true f.hasOwnProperty('constructor'); //false f instanceof Object; //true 

为什么没有改写 constructor，因为 F 在外面起不了作用的，如果要判断只能根据传入对象的构造函数判断，这也是为什么后面会进一步称其为寄生式继承，因为没有独立的自定义类型。 这也就是 ES5 中的 Object.create, 只到这里没有意义，还要有增强的功能。

var f = Object.create(new Object()); f.localFn = function () {} 

封装一下

function createAnother (o) { var f = Object.create(o); f.localFn = function () {}; return f; } 

反过头看下更精细的控制，共享的东西放在原型对象上，本地内容放在构造函数里。 这就叫组合继承。

function F () { this.localVal = 0; this.localFn = function () {} } F.prototype = { constructor: F, shareVal: 1, shareFn: function () {} } 

如果要从 F 继承下去呢？

function S () { F.call(this); } S.prototype = new F(); S.prototype.cOnstructor= S; 

为了避免两次调用 F 的问题，我们尝试直接基于 F.prototype。

function S () { F.call(this); } S.prototype = F.prototype; S.prototype.cOnstructor= S; var s = new S(); s.cOnstructor=== S; //true s instanceof S; //true S.prototype.__proto__.cOnstructor=== F; //false 

问题在于 S 和 F 原型相同，破坏了继承的层级结构。

function S () { F.call(this); } S.prototype = Object.create(F.prototype); S.prototype.cOnstructor= S; var s = new S(); s.cOnstructor=== S; //true s instanceof S; //true S.prototype.__proto__.cOnstructor=== F; //true 

这里实际借助了替换构造函数，避免实际构造函数的两次执行。这就是寄生组合式继承。