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

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

首先最简单的：

var o = new Object();

Object.prototype === o.__proto__; //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

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