JavaScript中对象的 constructor 属性介绍

例子1：
//定义构造函数
function P(age){
this.age=age;
}
//给原型添加方法
P.prototype.wel=function(){
console.log(this.age);
};
//实例化一个p对象
var p=new P(21);
//测试对象的方法
p.wel(); //21
// 测试对象的constructor属性
p.constructor;
//function P(age){
this.age=age;
}
这个例子实例对象的constructor属性指向构造函数，是正确的，但是请看下面的例子。
例子2：
//定义构造函数
function P(age){
this.age=age;
}
//给原型添加方法
P.prototype={
wel:function(){
console.log(this.age);
},};
//实例化一个p对象
var p=new P(21);
//测试对象的方法
p.wel(); //21
// 测试对象的constructor属性
p.constructor;
//function Object() { [native code] }

结果看到，虽然例子1和例子2构造函数的功能一样，实例化的对象也有功能一样的方法，但是因为定义构造函数的原型对象的方法不同，例1只单独改变了原型对象某一个属性，而例2整体改变了原型对象，导致实例化之后对象的constructor属性也改变了。

不过用例2这种方法在创建构造函数的情况应该很多，So，constructor这个属性很不可靠。

从上面的例子其实可以看出来，constructor属性并不是实例化的对象的属性，而是构造函数的原型对象的constructor属性。
p.hasOwnProperty("constructor"); //false
P.prototype.hasOwnProperty("constructor");//true

p.constructor通过原型链往上找到其原型对象的constructor属性。

对于例2，如果手动给P的prototype.constructor属性赋值P，
P.prototype.constructor=P;
则还是可以用的，但是这就要看个人习惯了。

摘自：JavaScript中对象的 constructor 属性的介绍

以下为原创：

上面摘抄内容说的都是对象的constructor属性，对象都有constructor属性，constructor用于保存创建当前对象的函数（javascript高级程序设计）。经过上述实验我们可以知道，准确的来讲，实例对象的constructor属性等于其构造函数的原型对象的constructor属性。

既然如此，函数类型也是对象，所以函数类型也有constructor属性，它的constructor属性一般是Function() { [native code] }

function P(age){
this.age=age;
}
P.constructor  //console:  function Function() { [native code] }

但是constructor属性是可以变更的，所以未必真的指向对象的构造函数，只是一个提示。 （摘自知乎： JavaScript 中对象的 constructor 属性的作用是什么？）

如果构造函数是有返回值的，通过new 构造函数的方式得到的，只是返回值，而并不是构造函数的实例对象。

function P(){
  function setAge(age){
    this.age=age;
 }
  return setAge;
}
var setAgeFun = new P();
setAgeFun.constructor    //console:  function Function() { [native code] }

怎么让返回值成为构造函数的实例对象,让它具有这个提示效果呢？

既然constructor属性是可以变更的，我们只需让返回值的constructor属性等于构造函数就好。

function P(){
  function setAge(age){
    this.age=age;
 }
  setAge.constructor=P;
  return setAge;
}
var setAgeFun = new P();
setAgeFun.constructor
/* console: function P(){
  function setAge(age){
    this.age=age;
 }
  setAge.constructor=P;
  return setAge;
} */

ps（个人见解）: java 中构造函数是没有返回值的，所以new 构造函数得到就一定是实例对象，但是在javascript中，函数都可以返回值，所以对于有返回值的构造函数，

new出来后就不是实例对象

同时对象也都具有属性__proto__，可称为隐式原型，一个对象的隐式原型指向构造该对象的构造函数的原型，这也保证了实例能够访问在构造函数原型中定义的属性和方法。

方法(Function)方法这个特殊的对象，除了和其他对象一样有上述_proto_属性之外，还有自己特有的属性——原型属性（prototype），这个属性是一个指针，指向一个对象，这个对象的用途就是包含所有实例共享的属性和方法（我们把这个对象叫做原型对象）。原型对象也有一个属性，叫做constructor，这个属性包含了一个指针，指回原构造函数。

简化了Mootool.js中创建class的源码进行解读：

var Class =function(){
   console.log("这是一个用来创建类的构造函数,创建出了某个类");
   var klass =function(){
      console.log("这是一个类，用来创建对象的构造函数，创建出了某个对象");
   }
   klass.constructor = Class;
   return klass;
}
var people = new Class();   // console:这是一个用来创建类的构造函数,创建出了某个类

var person =new people()    // console: 这是一个类，用来创建对象的构造函数，创建出了某个对象

people.constructor
/* console: 
function(){
   console.log("这是一个用来创建类的构造函数,创建出了某个类");
   var klass =function(){
      console.log("这是一个类，用来创建对象的构造函数，创建出了某个对象");
   }
   klass.constructor = Class;
   return klass;
} */
person.constructor
/* console:
function(){
      console.log("这是一个类，用来创建对象的构造函数，创建出了某个对象");
   } */

备注：var people = new Class();  var person =new people() 可以看出，这上面用到了函数柯里化的知识。Class的写法是一种函数中返回函数的写法。

我们再比较以下2种写法：

var Class =function(){
   console.log("这是一个用来创建类的构造函数,创建出了某个类");
   var klass =function(){
      console.log("这是一个类，用来创建对象的构造函数，创建出了某个对象");
   }
   return klass;
}
var people = new Class();   // console:这是一个用来创建类的构造函数,创建出了某个类

var person =new people()    // console: 这是一个类，用来创建对象的构造函数，创建出了某个对象

people.constructor

//console: Function() { [native code] }

person.constructor
/* console:
function(){
      console.log("这是一个类，用来创建对象的构造函数，创建出了某个对象");
   }
*/

var Class =function(){
   console.log("这是一个用来创建类的构造函数,创建出了某个类");
   var klass =function(){
      console.log("这是一个类，用来创建对象的构造函数，创建出了某个对象");
      this.constructor = klass;
   }
   klass.constructor = Class;
   return klass;
}

var people = new Class();   // console:这是一个用来创建类的构造函数,创建出了某个类


var person =new people()    // console: 这是一个类，用来创建对象的构造函数，创建出了某个对象


people.constructor
/* console: 
var Class =function(){
   console.log("这是一个用来创建类的构造函数,创建出了某个类");
   var klass =function(){
      console.log("这是一个类，用来创建对象的构造函数，创建出了某个对象");
      this.constructor = klass;
   }
   klass.constructor = Class;
   return klass;
} */

person.constructor
/* console: 
function(){
      console.log("这是一个类，用来创建对象的构造函数，创建出了某个对象");
      this.constructor = klass;
   } */

可以看出

var Class =function(){
   console.log("这是一个用来创建类的构造函数,创建出了某个类");
   var klass =function(){
      console.log("这是一个类，用来创建对象的构造函数，创建出了某个对象");
      this.constructor = klass;      //可以不用显式指定，可能是因为klass函数没有返回值
   }
   klass.constructor = Class;   /*如果想表明klass对象是通过Class函数创建出来的这层关系，要显式指定，
                                 否则其constructor属性是function.prototype的constructor属性 */
   return klass;
}

最后附上Mootools.js中创建Class的源码：

var Class = function(properties) {   //这个properties的作用似乎是将properties对象包装成一个类
  properties = properties || {};
  var klass = function() {
    for ( var key in this) {
      if (typeof this[key] != 'function')
        this[key] = $.unlink(this[key]);  //解除原对象的引用
    }
    this.constructor = klass;      
    if (Class.prototyping)
      return this;
    var instance = this.initialize ? this.initialize.apply(this, arguments)
        : this;  //如果这个类有initialize方法，则将initialize方法作为构造函数返回
    //typize
    this.$$family = 'class';
    return instance;
  };
 
  for ( var mutator in Class.Mutators) {
    if (!properties[mutator])
      continue;
    properties = Class.Mutators[mutator](properties, properties[mutator]);  //properties对象有implements属性，说明它需要实现其他接口
    delete properties[mutator];
  }
 
  $.extend(klass, this);
  klass.constructor = Class;
  klass.prototype = properties;  
  return klass;
};