<pre name="code" class="javascript">function A(c){
this.b = c;
this.d =function(){
alert(this.b);
}
}
var obj = new A('test');
alert(obj.constructor);//function A(){}
alert(A.prototype.constructor);//function A(){}
1,第一个alert输出的原因
首先obj是没有constructor,于是在obj.__proto__中找。因为var obj = new a('test')所以obj.__proto__ = a.prototype。所以输出是a.prototype.constructor
2,如JavaScript高级设计P162所说
a,每个构造函数都有一个原型对象,原型对象都包含一个指向构造函数的指针(object.prototype.constructor),因为原型对象里还能有其他属性,如object.prototype.x = 1,每个实例都包含一个指向原型对象的指针(即__proto__)
3,参考 http://www.blogjava.net/heavensay/archive/2013/10/20/405440.html
function Animal(){
}
var anim = new Animal();
console.log((anim.__proto__===Animal.prototype)); //true,因为anim.__proto__指向父类的prototyp
console.log(Animal.__proto__===Function.prototype)); //true,都为function Empty(){}
console.log(Animal.prototype.__proto__===Object.prototype)); //true,都为Object{}
4,每个函数都有名为prototype的属性,用于引用原型对象。此原型对象又有名为constructor的属性,它反过来应用函数本身。这是一种循环引用(Animal.prototype.constructor == Animal)
如何查找一个对象的constructor,就是在该对象的原型链上寻找碰到的第一个constructor属性所指向的对象。
5,所有对象的__proto__指向其构造器的prototype
var obj = {name: 'jack'}
var arr = [1,2,3]
var reg = /hello/g
var date = new Date
var err = new Error('exception')
console.log(obj.__proto__ === Object.prototype) // true
console.log(arr.__proto__ === Array.prototype) // true
console.log(reg.__proto__ === RegExp.prototype) // true
console.log(date.__proto__ === Date.prototype) // true
console.log(err.__proto__ === Error.prototype) // true
6,每个对象都有个constructor属性,用来获得其构造器
function Person(name) {
this.name = name
}
// 重写原型
Person.prototype = {
getName: function() {}
}
var p = new Person('jack')
console.log(p.__proto__ === Person.prototype) // true
console.log(p.__proto__ === p.constructor.prototype) // false
Person.prototype赋值的是对象直接量{getName: function () {}},使用对象直接量定义的对象,其构造器指向Object
var p = {}
console.log(Object.prototype) // 为一个空的对象{}
console.log(p.constructor === Object) // 对象直接量方式定义的对象其constructor为Object
console.log(p.constructor.prototype === Object.prototype) // 为true,不解释
函数的constructor和函数prototype里的constructor。如上例中Person.prototype赋值给对象直接量,则prototype里的constructor指向Object。然而Person.constructor还是指向function
总结:
函数对象有prototype和__proto__,constructor三个属性,constructor反过来引用了对象本身(或说constructor指向其构造器)