JavaScript类和继承:constructor 属性探秘

constructor属性始终指向创建当前对象的构造函数。比如下面例子:

 代码如下 复制代码
// 等价于 var foo = new Array(1, 56, 34, 12);
var arr = [1, 56, 34, 12];
console.log(arr.constructor === Array); // true
// 等价于 var foo = new Function();
var Foo = function() { };
console.log(Foo.constructor === Function); // true
// 由构造函数实例化一个obj对象
var obj = new Foo();
console.log(obj.constructor === Foo); // true
 
// 将上面两段代码合起来,就得到下面的结论
console.log(obj.constructor.constructor === Function); // true

但是当constructor遇到prototype时,有趣的事情就发生了。

我们知道每个函数都有一个默认的属性prototype,而这个prototype的constructor默认指向这个函数。如下例所示:

 代码如下 复制代码
function Person(name) {
 this.name = name;
};
Person.prototype.getName = function() {
 return this.name;
};
var p = new Person("ZhangSan");
 
console.log(p.constructor === Person); // true
console.log(Person.prototype.constructor === Person); // true
// 将上两行代码合并就得到如下结果
console.log(p.constructor.prototype.constructor === Person); // true

当时当我们重新定义函数的prototype时(注意:和上例的区别,这里不是修改而是覆盖),constructor属性的行为就有点奇怪了,如下示例:

 代码如下 复制代码
function Person(name) {
 this.name = name;
};
Person.prototype = {
 getName: function() {
 return this.name;
 }
};
var p = new Person("ZhangSan");
console.log(p.constructor === Person); // false
console.log(Person.prototype.constructor === Person); // false
console.log(p.constructor.prototype.constructor === Person); // false

为什么呢?

原来是因为覆盖Person.prototype时,等价于进行如下代码操作:

 代码如下 复制代码
Person.prototype = new Object({
 getName: function() {
 return this.name;
 }
});

而constructor属性始终指向创建自身的构造函数,所以此时Person.prototype.constructor === Object,即是:

 代码如下 复制代码
function Person(name) {
 this.name = name;
};
Person.prototype = {
 getName: function() {
 return this.name;
 }
};
var p = new Person("ZhangSan");
console.log(p.constructor === Object); // true
console.log(Person.prototype.constructor === Object); // true
console.log(p.constructor.prototype.constructor === Object); // true

怎么修正这种问题呢?方法也很简单,重新覆盖Person.prototype.constructor即可:

 代码如下 复制代码

function Person(name) {
 this.name = name;
};
Person.prototype = new Object({
 getName: function() {
 return this.name;
 }
});
Person.prototype.constructor = Person;
var p = new Person("ZhangSan");
console.log(p.constructor === Person); // true
console.log(Person.prototype.constructor === Person); // true
console.log(p.constructor.prototype.constructor === Person); // true

时间: 2024-11-09 02:51:22

JavaScript类和继承:constructor 属性探秘的相关文章

JavaScript类和继承 constructor属性_js面向对象

constructor属性始终指向创建当前对象的构造函数.比如下面例子:比如下面例子: 复制代码 代码如下: // 等价于 var foo = new Array(1, 56, 34, 12); var arr = [1, 56, 34, 12]; console.log(arr.constructor === Array); // true // 等价于 var foo = new Function(); var Foo = function() { }; console.log(Foo.co

JavaScript类和继承 prototype属性_js面向对象

我们已经在第一章中使用prototype属性模拟类和继承的实现. prototype属性本质上还是一个JavaScript对象. 并且每个函数都有一个默认的prototype属性. 如果这个函数被用在创建自定义对象的场景中,我们称这个函数为构造函数. 比如下面一个简单的场景: 复制代码 代码如下: // 构造函数 function Person(name) { this.name = name; } // 定义Person的原型,原型中的属性可以被自定义对象引用 Person.prototype

JavaScript类和继承 this属性使用说明_js面向对象

this属性表示当前对象,如果在全局作用范围内使用this,则指代当前页面对象window: 如果在函数中使用this,则this指代什么是根据运行时此函数在什么对象上被调用. 我们还可以使用apply和call两个全局方法来改变函数中this的具体指向. 先看一个在全局作用范围内使用this的例子: 复制代码 代码如下: <script type="text/javascript"> console.log(this === window); // true consol

javascript 类式继承与原型继承

JavaScript类式继承 为了更好的了解JavaScript中类式继承的原理,我们先看一个简单的例子. //Super class function Person(){ this.name='张胜利'; this.age=23; this.getName = function(){ return this.name; }; }; Person.prototype.getAge = function(){ return this.age; }; //sub class function rea

JavaScript类和继承:constructor属性

constructor属性始终指向创建当前对象的构造函数.比如下面例子: // 等价于 var foo = new Array(1, 56, 34, 12);   var arr = [1, 56, 34, 12];   console.log(arr.constructor === Array); // true   // 等价于 var foo = new Function();   var Foo = function() { };   console.log(Foo.constructo

Javascript的构造函数和constructor属性_javascript技巧

例如,在Chrome下调试如下程序,很清楚的展示了这点:   然而事情并不是这么简单.再看下面的代码: 很显然,这个时候obj的constructor已经不再是创建它的函数,注意到obj.name也是undefined,因此修改构造函数的prototype的contructor并不会影响构造函数所产生的对象.真正的原因是:一个对象的constructor是它的构造函数的prototype.constructor,而每一个函数都有一个prototype,默认情况下,这个prototype有一个co

javascript“类”与继承总结和回顾2

前面一篇文章,我简单的讲了Es6以前js实现"类"的三种方式.但是继承的方式,我只简单写了一下极简主义继承.这篇文章在上篇文章基础之上,我再写写js继承的几种方式,最后再和大家一起看看ES6中类的实现方式. js继承 关于继承,网上也有很多资料可以查询,但是很多朋友对其理解的不够深入.讲到继承,假如你不去查资料,猛地一下,可能说不出个所以然来.这就说明我们的基础知识打的不够扎实.没有理解透彻.今天,我站在前辈的基础之上,再来和大家一起回顾一下这个 继承. 继承最常用的两种方式如下: 原

javascript new后的constructor属性_js面向对象

js对象生成时: 如:function BB(a){this.a="kkk"} var b=new BB();这时b是对象有了BB的的属性prototype所指向的prototype对象:prototype对象有constructor属性指向BB这个函数:所以alert(b.constructor==BB.prototype.constructor) //true 这里的"有了"的执行过程是先查看b有没有此属性让后去查看prototype里的属性值,不是简单的A=B

javascript“类”与继承总结和回顾

我们先来总结一下js定义"类"的几种方法: 方法一:构造函数法 这个方法是比较经典的方法,我们会经常见到.生成实例的时候,使用new关键字.类的属性和方法,还可以定义在构造函数的prototype对象之上. function Person(name,age,job){     this.name=name;     this.age=age;     this.job=job; } Person.prototype.sayName=function(){     alert(this.