javascript中的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中的原型继承了。示意图如下所示：

每个函数都有一个默认的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属性，则哪些预定义的方法就消失了），但是我们可以向其中添加自己的扩展方法。

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

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

Object.constructor //对象的构造函数

Object.hasOwnProperty() //检查对象属性是否被继承

Object.isPrototypeOf() //检查一个对象是否是另外一个对象的原型

Object.propertyIsEnumerable() //是否可以通过for/in 循环看到属性

Object.toLocaleString() //返回对象的本地字符串表示

Object.toString() //定义一个对象的字符串表示

Object.valueOf() //制定对象的原始值

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