关于JS中的constructor与prototype的总结-阿里云开发者社区

开发者社区> 开发与运维> 正文

关于JS中的constructor与prototype的总结

简介: prototype 属性使您有能力向对象添加属性和方法 constructor 属性返回对创建此对象的数组函数的引用

定义和用法

prototype 属性使您有能力向对象添加属性和方法

constructor 属性返回对创建此对象的数组函数的引用

语法

object.prototype.name=value

object.constructor

在JS中有一个function的东西。一般人们叫它函数

function Person(name){  
    console.log(name);  
}  
Person('js');   //js 

在Javascript语言中,constructor属性是专门为function而设计的,它存在于每一个function的prototype属性中。这个constructor保存了指向function的一个引用

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 Person(name){  
    this.name=name;  
    this.showMe=function(){  
        alert(this.name);  
    }  
};  
var one=new Person('<a href="#" class='replace_word' title="JavaScript知识库" target='_blank'>JavaScript</a>');  
one.showMe();   //<a href="#" class='replace_word' title="JavaScript知识库" target='_blank'>javascript</a> 

按照javascript的说法,function定义的这个Person就是一个Object(对象),而且还是一个很特殊的对象,这个使用function定义的对象与使用new操作符生成的对象之间有一个重要的区别:function定义的对象有一个prototype属性,使用new生成的对象就没有这个prototype属性

function a(c){
    this.b = c;
    this.d =function(){
        alert(this.b);
    }
}
var obj = new a('test');
console.log(typeof obj.prototype);   //undefine
console.log(typeof a.prototype);   //object
console.log(a.prototype);
console.log(obj.__proto__ === a.prototype)   //true

上面的例子可以看出函数的prototype 属性又指向了一个对象,这个对象就是prototype对象

a.prototype 包含了2个属性,一个是constructor ,另外一个是__proto__。这个constructor 就是我们的构造函数a,那么__proto__ 是什么呢?

这个就涉及到了原型链的概念:每个对象都会在其内部初始化一个属性,就是__proto__,当我们访问一个对象的属性时,如果这个对象内部不存在这个属性,那么他就会去__proto__里找这个属性,这个__proto__又会有自己的__proto__,于是就这样 一直找下去

在这里我们来分析出new 运算符做了这些事情

var obj={};    也就是说,初始化一个对象obj。
obj.__proto__=a.prototype;
a.call(obj);   也就是说构造obj,也可以称之为初始化obj

我们将这个例子改造一些,变得复杂一点

function a(c){
    this.b = c;
    this.d =function(){
        console.log(this.b);
    }
}
a.prototype.test = function(){
    console.log(this.b);
}
var obj = function (){}
obj.prototype = new a('test');
obj.prototype.test1 =function(){
    console.log(22222);
}
var t = new obj('test');
t.test();   //console.log('test');

我们来分析下这个过程:

var t = new obj('test'); 我们可以得到 t.__proto__ = obj.prototype,但是上面指定obj.prototype =new a('test'); 可以这样来看下

obj.prototype = p, p = new a('test'); p.__proto__ = a.prototype;

那么obj.prototype.__proto__ = a.prototype,由 t.__proto__ = obj.prototype 可以得出 t.__proto__.__proto__ = a.prototype,所以对象t先去找本身的prototype 是否有test函数,发现没有,结果再往上级找,即 t.__proto__ ,亦即obj.prototype 寻找test函数 ,但是obj.prototype 也没有这个函数,然后再往上找。即t.__proto__.__proto__ 找,由于t.__proto__.__proto__ = a.prototypea.prototype 中找到了这个方法,输出了alert('test')

从这里可以分析得出一个结论,js中原形链的本质在于 proto

function a(c){
    this.b = c;
    this.d =function(){
        console.log(this.b);
    }
}
var obj  = new a('test');
console.log(obj.constructor);//function a(){}
console.log(a.prototype.constructor);//function a(){}

根据上面讲到的__proto__ 我们来分析下,首先obj是没有constructor 这个属性的,但是 obj.__proto__ = a.prototype;就从

a.prototype中寻找,而 a.prototype.constructor 是就a,所有两者的结果是一一样的

接着看继承是如何实现的

function Person(name){  
    this.name=name;  
    this.showMe=function(){  
        console.log(this.name);  
    }  
};   
Person.prototype.from=function(){  
    console.log('I come from prototype.');  
}
function SubPerson(){}  
SubPerson.prototype=new Person();
var subOne=new SubPerson();  
subOne.from();//I come from prototype.  
console.log(subOne.constructor);//function Person(name) {...};  
console.log(SubPerson.prototype.constructor);//function Person(name) {...};  

更实际点的意义在于:一个子类对象可以获得其父类的所有属性和方法,称之为继承。继承的实现很简单,只需要把子类的prototype设置为父类的一个对象即可。注意这里说的可是对象哦

function Person(name){  
    this.name=name;  
    this.showMe=function(){  
        console.log(this.name);  
    }  
};    
Person.prototype.from=function(){  
    console.log('I come from prototype.');  
}  
var father=new Person('js');//为了下面演示使用showMe方法,采用了js参数,实际多采用无参数  
console.log(father.constructor);//查看构造函数,结果是:function Person(name) {...};  
function SubPer(){}  
SubPer.prototype=father;//注意这里  
SubPer.prototype.constructor=SubPer;
var son=new SubPer();  
son.showMe();//js  
son.from();//I come from prototype.  
console.log(father.constructor);//function SubPer(){...}  
console.log(son.constructor);//function SubPer(){...}  
console.log(SubPer.prototype.constructor);//function SubPer(){...}  

之前提到constructor易变,那是因为函数的prototype属性容易被更改,我们用时下很流行的编码方式来说明问题:

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

初看这种方式并无问题,但是你会发现下面的代码失效了:

var f = new F(); 
console.log(f.constructor === F); // output false  

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

当然是!只不过构造函数F的原型被开发者重写了,这种方式将原有的prototype对象用一个对象的字面量{}来代替,而新建的对象{}只是Object的一个实例,系统(或者说浏览器)在解析的时候并不会在{}上自动添加一个constructor属性,因为这是function创建时的专属操作,仅当你声明函数的时候解析器才会做此动作。

然而你会发现constructor并不是不存在的,下面代码可以测试它的存在性:

console.log(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

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享:
开发与运维
使用钉钉扫一扫加入圈子
+ 订阅

集结各类场景实战经验,助你开发运维畅行无忧

其他文章