转载

javascript中的constructor&&prototype

Object.constructor,prototype

对象的prototype和constructor是两个重要的属性，他们总是成对出现，提到constructor的地方，不得不涉及到另外一个非常重要的属性prototype,它是js中基于原型继承的一个基础。所谓的成对出现，是因为function的prototype属性指向了一个prototype对象，在prototype对象中又有一个constructor属性，这个constructor属性同样指向一个constructor对象，而这个constructor对象恰恰就是这个function函数本身。

function Person(name)  {   this.name=name;   this.showMe=function()      {       alert(this.name);      }  };  var one=new Person('JavaScript');  one.showMe();//JavaScript

很多人见到了久违的new操作符，于是就叫Person为“类”，可是又没有关键字class的出现，觉得叫“类”有点勉强。于是退而求其次叫Person为类的构造函数。这些概念好像都没有错，之所以出现这样的情况，可能是因为大家都学习了传统的面向对象语言（c++，c#，java等），还有一种思维定势吧。为了让javascript也面向对象，要在javascript中找到与传统面向对象语言的影子。可是按照javascript的说法，function定义的这个Person就是一个Object(对象),而且还是一个很特殊的对象，这个使用function定义的对象与使用new操作符生成的对象之间有一个重要的区别。这个区别就是function定义的对象有一个prototype属性，使用new生成的对象就没有这个prototype属性。（这个之前没有注意过这个区别，代码测试下竟然还真是）

function Person(name)  {   this.name=name;   this.showMe=function()      {       alert(this.name);      }  };  var one=new Person('js');  alert(one.prototype)//undefined  alert(typeof Person.prototype);//object  alert(Person.prototype.constructor);//function Person(name) {...};

one这个对象竟然没有prototype属性。。。

function Person(name)  {   this.name=name;   this.showMe=function()      {       alert(this.name);      }  };  Person.prototype.from=function()  {    alert('I come from prototype.');  }  var one=new Person('js');  one.showMe();//js,这个结果正常  one.from();//I come from prototype.，这个结果有一点奇怪

要解释这个结果就要仔细研究一下new这个操作符了

var one=new Person('js');

这个语句执行的过程可以分成下面的语句：

var one={};    Person.call(one,'js');

按照《悟透javascript》书中说的，new形式创建对象的过程实际上可以分为三步：

第一步是建立一个新对象（叫A吧）；

第二步将该对象（A）内置的原型对象设置为构造函数(就是Person)prototype 属性引用的那个原型对象；

第三步就是将该对象（A）作为this 参数调用构造函数(就是Person)，完成成员设置等初始化工作。

其中第二步中出现了一个新名词就是内置的原型对象__prop__，注意这个新名词跟prototype对象不是一回事，__prop__（图中标记的inobj）就指向了函数Person的prototype对象。在person的prototype对象中出现的任何属性或者函数都可以在one对象中直接使用，这个就是javascript中的原型继承了。示意图如下所示：

javascript中的constructor&&prototype

每个函数都有一个默认的prototype属性。如果这个函数被用在创建自定义对象的场景中，我们称这个函数为构造函数。比如下面一个简单的例子：

// 构造函数 function Person(name) {  this.name = name; } // 定义Person的原型，原型中的属性可以被自定义对象引用 Person.prototype = {  getName: function() {   return this.name;  } } var zhang = new Person("ZhangSan"); console.log(zhang.getName());   // "ZhangSan"

作为类比，我们考虑下JavaScript中的数据类型 - 字符串（String）、数字（Number）、数组（Array）、对象（Object）、日期（Date）等。

我们有理由相信，在JavaScript内部这些类型都是作为构造函数来实现的；

同时对数组操作的很多方法（比如concat、join、push）应该也是在prototype属性中定义的。

实际上，JavaScript所有的固有数据类型都具有只读的prototype属性（因为如果修改了这些类型的prototype属性，则哪些预定义的方法就消失了），但是我们可以向其中添加自己的扩展方法。

Object.constructor遇到prototype的问题

constructor始终指向创建当前对象的构造函数。

        var arr = [1, 56, 34, 12];// 等价于 var foo = new Array(1, 56, 34, 12);         console.log(arr.constructor === Array); // true                var Foo = function() { };  // 等价于 var foo = new 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

Object的常用方法

javascript中的一切皆对象，而这些对象的有一个最父层的类就是Object,常用的一些属性方法汇总一下，这些方法在判断上述问题以及其他方面很有用。

Object.constructor //对象的构造函数  Object.hasOwnProperty() //检查对象属性是否被继承  Object.isPrototypeOf() //检查一个对象是否是另外一个对象的原型  Object.propertyIsEnumerable() //是否可以通过for/in 循环看到属性  Object.toLocaleString() //返回对象的本地字符串表示  Object.toString() //定义一个对象的字符串表示  Object.valueOf() //制定对象的原始值

最近从图书馆把那边厚厚的《javascript高级程序设计》借过来了，看看单单事件就能将讲那么厚厚一章，打算搞一个基础知识系列~~求监督和共勉

正文到此结束