构造函数对象[置顶] 揭开Javascript属性constructor/prototype的底层原理

题记：写这篇博客要主是加深自己对构造函数对象的认识和总结实现算法时的一些验经和训教，如果有错误请指出，万分感谢。

在Javascript语言中，constructor属性是专门为function而计划的，它存在于每个function的prototype属性中。这个constructor保存了指向function的一个引用。在定义一个函数（代码如下所示）时，

function F() {
// some code
}.

JavaScript内部会执行如下几个动作：

为该函数添加一个原形属性（即prototype对象）.

为prototype对象额定添加一个constructor属性，并且该属性保存指向函数F的一个引用。



这样当我们把函数F作为自定义构造函数来创建对象的时候，对象实例内部会自动保存一个指向其构造函数（这里就是我们的自定义构造函数F）的prototype对象的一个属性__proto__，所以我们在每个对象实例中就可以拜访构造函数的prototype全部具有的全部属性和方法，就好像它们是实例自己的一样。

当然该实例也有一个constructor属性了（从prototype那里获得的），这时候constructor的作用就很显著了，因为在这时，每个对象实例都可以通过constrcutor对象拜访它的构造函数，请看上面代码：

var f = new F();
alert(f.constructor === F);// output true
alert(f.constructor === F.prototype.constructor);// output true

我们可以利用这个特性来完成上面的事件： 对象类型判断，如

if(f.constructor === F) {
// do sth with F
}

其实constructor的出现原本就是用来停止对象类型判断的，但是constructor属性易变，不可信赖。

我们有一种更加安全可靠的判定方法：instanceof 操作符。

上面代码仍然返回true

if(f instanceof F) {

// do sth with F

}.

原型链继承，由于constructor存在于prototype对象上，因此我们可以结合constructor沿着原型链找到最原始的构造函数，如上面代码：

function Base() {}
// Sub1 inherited from Base through prototype chain
function Sub1(){}
Sub1.prototype = new Base();
Sub1.prototype.constructor = Sub1;
Sub1.superclass = Base.prototype;
// Sub2 inherited from Sub1 through prototype chain
function Sub2(){}
Sub2.prototype = new Sub1();
Sub2.prototype.constructor = Sub2;
Sub2.superclass = Sub1.prototype;
// Test prototype chain
alert(Sub2.prototype.constructor);
// function Sub2(){}
alert(Sub2.superclass.constructor);
// function Sub1(){}
alert(Sub2.superclass.constructor.superclass.constructor);
// function Base(){}

上面的例子只是为了说明constructor在原型链中的作用，更实际一点的意义在于：一个子类对象可以获得其父类的全部属性和方法，称之为继承，关于继承我们有很多多少可以分析和讨论，本篇限于篇幅不在此讨论。

一个容易掉入的陷阱（gotchas） 之前提到constructor易变，那是因为函数的prototype属性容易被变动，我们用时下很流行的编码方法来说明问题，请看上面的示例代码：

每日一道理

我拽着春姑娘的衣裙，春姑娘把我带到了绿色的世界里。

function F() {}
F.prototype = {
_name: 'Eric',
getName: function() {
return this._name;
}
};

初看这类方法并无问题，但是你会发现上面的代码失效了：

var f = new F();

alert(f.constructor === F); // output false

怎么回事？F不是实例对象f的构造函数了吗？

当然是！只不过构造函数F的原型被开发者重写了，这类方法将原有的prototype对象用一个对象的字面量{}来取代。

而新建的对象{}只是Object的一个实例，系统（或者说浏览器）在剖析的时候其实不会在{}上自动添加一个constructor属性，因为这是function创建时的专属操作，仅当你声明函数的时候剖析器才会做此动作。

然而你会发现constructor其实不是不存在的，上面代码可以测试它的存在性：

alert(typeof f.constructor == 'undefined');// output false

既然存在，那这个constructor是从哪儿冒出来的呢？

我们要回头分析这个对象字面量{}。

因为{}是创建对象的一种简写，所以{}相当于是new Object()。

那既然{}是Object的实例，天然而然他获得一个指向构造函数Object()的prototype属性的一个引用__proto__，又因为Object.prototype上有一个指向Object本身的constructor属性。所以可以看出这个constructor其实就是Object.prototype的constructor，上面代码可以验证其论断：

alert(f.constructor === Object.prototype.constructor);//output true

alert(f.constructor === Object);// also output true

一个处理办法就是手动恢复他的constructor，上面代码非常好地处理了这个问题：

function F() {}
F.prototype = {
constructor: F, /* reset constructor */
_name: 'Eric',
getName: function() {
return this._name;
}
};

以后一切恢复正常，constructor重新获得的构造函数的引用，我们可以再一次测试上面的代码，此次返回true
var f = new F();
alert(f.constructor === F); // output true this time ^^
解惑：构造函数上怎么还有一个constructor？它又是哪儿来的？
仔细的朋友会发现，像JavaScript内建的构造函数，如Array, RegExp, String, Number, Object, Function等等居然自己也有一个constructor:
alert(typeof Array.constructor != 'undefined');// output true
经过测试发现，此物非彼物它和prototype上constructor不是同一个对象，他们是共存的：
alert(typeof Array.constructor != 'undefined');// output true
alert(typeof Array.prototype.constructor === Array); // output true
不过这件事件也是好懂得的，因为构造函数也是函数。
是函数说明它就是Function构造函数的实例对象，天然他内部也有一个指向Function.prototype的内部引用__proto__啦。
因此我们很容易得出论断，这个constructor（构造函数上的constructor不是prototype上的）其实就是Function构造函数的引用：
alert(Array.constructor === Function);// output true
alert(Function.constructor === Function); // output true
OK, constructor从此原形毕露，你不在对它陌生了~

文章结束给大家分享下程序员的一些笑话语录： 《诺基亚投资手机浏览器UCWEB，资金不详或控股》杯具了，好不容易养大的闺女嫁外国。（心疼是你养的吗？中国创业型公司创业初期哪个从国有银行贷到过钱？）