JS中的prototype,__proto__和constructor

<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指向其构造器）