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对象訪问它的构造函数，请看以下代码：

 







[javascript] view plaincopy









var f = new F();

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

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





我们能够利用这个特性来完毕以下的事情： 对象类型推断，如







[javascript] view plaincopy









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在原型链中的作用，更实际一点的意义在于：一个子类对象能够获得其父类的全部属性和方法。称之为继承，关于继承我们有好多能够分析和讨论，本篇限于篇幅不在此讨论。

一个easy掉入的陷阱（gotchas） 之前提到constructor易变，那是由于函数的prototype属性easy被更改。我们用时下非常流行的编码方式来说明问题。请看以下的演示样例代码：



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__啦。

因此我们非常easy得出结论，这个constructor（构造函数上的constructor不是prototype上的）事实上就是Function构造函数的引用：

alert(Array.constructor === Function);// output true

alert(Function.constructor === Function); // output true

OK, constructor从此真相大白，你不在对它陌生了

本文转自：原帖地址：http://blog.csdn.net/hikvision_java_gyh/article/details/8937157。