JavaScript 面向对象 (prototype 原型模式)

一、 JavaScript 设计思想

　　1994年，网景公司（Netscape）发布了Navigator浏览器0.9版。这是历史上第一个比较成熟的网络浏览器，轰动一时。但是，这个版本的浏览器只能用来浏览，不具备与访问者互动的能力。比如，如果网页上有一栏"用户名"要求填写，浏览器就无法判断访问者是否真的填写了，只有让服务器端判断。如果没有填写，服务器端就返回错误，要求用户重新填写，这太浪费时间和服务器资源了。

　　因此，网景公司急需一种网页脚本语言，使得浏览器可以与网页互动。工程师_Brendan Eich_负责开发这种新语言。他觉得，没必要设计得很复杂，这种语言只要能够完成一些简单操作就够了，比如判断用户有没有填写表单。

　　1994年正是面向对象编程（object-oriented programming）最兴盛的时期，C++是当时最流行的语言，而Java语言的1.0版即将于第二年推出，Sun公司正在大肆造势。

　　Brendan Eich无疑受到了影响，Javascript里面所有的数据类型都是对象（object），这一点与Java非常相似。但是，他随即就遇到了一个难题，到底要不要设计"继承"机制呢？  

　　如果真的是一种简易的脚本语言，其实不需要有"继承"机制。但是，Javascript里面都是对象，必须有一种机制，将所有对象联系起来。所以，Brendan Eich最后还是设计了"继承"。

　　但是，他不打算引入"类"（class）的概念，因为一旦有了"类"，Javascript就是一种完整的面向对象编程语言了，这好像有点太正式了，而且增加了初学者的入门难度。

　　他考虑到，C++和Java语言都使用new命令，生成实例。

　　　　C++的写法是： 
    　　　　ClassName *object = new ClassName(param);

　　　　Java的写法是:
    　　　　Foo foo = new Foo();

　   因此，他就把new命令引入了Javascript，用来从原型对象生成一个实例对象。但是，Javascript没有"类"，怎么来表示原型对象呢？
　　这时，他想到C++和Java使用new命令时，都会调用"类"的构造函数（constructor）。他就做了一个简化的设计，在Javascript语言中，new命令后面跟的不是类，而是构造函数。 

　　例：　

    现在有一个叫做DOG的构造函数，表示狗对象的原型。

    　　function DOG(name){
        　　this.name = name;
    　　}

　　　　对这个构造函数使用new，就会生成一个狗对象的实例。

    　　var dogA = new DOG('大毛');
    　　alert(dogA.name); // 大毛

　　　　注意构造函数中的this关键字，它就代表了新创建的实例对象。

　　new运算符的缺点

　　　  用构造函数生成实例对象，有一个缺点，那就是无法共享属性和方法。

　　　　比如：

　　　　　　在DOG对象的构造函数中，设置一个实例对象的共有属性species

    　　　　function DOG(name){
        　　　　this.name = name;
        　　　　this.species = '犬科';
    　　　　}

　　　　　　然后，生成两个实例对象：

    　　　　var dogA = new DOG('大毛');
    　　　　var dogB = new DOG('二毛');

　　　　　　这两个对象的species属性是独立的，修改其中一个，不会影响到另一个。　　　　　

    　　　　dogA.species = '猫科';
    　　　　alert(dogB.species); // 弹出的值为"犬科"，它不受 dogA 的影响

　　　　　　每一个实例对象，都有自己的属性和方法的副本。这不仅无法做到数据共享，也是极大的资源浪费。

二、prototype属性的引入

　　Brendan Eich 为构造函数设置一个prototype属性。

　　这个属性包含一个对象（以下简称"prototype对象"），所有实例对象需要共享的属性和方法，都放在这个对象里面；那些不需要共享的属性和方法，就放在构造函数里面。

　　实例对象一旦创建，将自动引用prototype对象的属性和方法。也就是说，实例对象的属性和方法，分成两种，一种是本地的，另一种是引用的。

　　例：

    function DOG(name){
        this.name = name;
    }
    DOG.prototype = { species : '犬科' };
    
    var dogA = new DOG('大毛');
    var dogB = new DOG('二毛');
    
    alert(dogA.species); // 犬科
    alert(dogB.species); // 犬科

　　现在，species属性放在prototype对象里，是两个实例对象共享的。只要修改了prototype对象，就会同时影响到两个实例对象。

    DOG.prototype.species = '猫科';
    alert(dogA.species); // 猫科
    alert(dogB.species); // 猫科

 三、Prototype原型模式

　　原型对象实际上就是构造函数的一个实例对象，和普通的实例对象没有本质上的区别。可以包含特定类型的所有实例的共享属性或者方法。 这个prototype的属性值是一个对象（属性的集合），默认的只有一个叫做constructor的属性，指向这个函数本身。  

　　比如我们简单定义一个SuperType名字的函数

    function SuperType(){

    }

　　 里面什么属性也没有在函数内部是这个样子的　　

　　　

　　从上图我们看到，函数里面虽然什么都没有，但是有一个默认的prototype属性,它是一个对象，它指向的是自己的地址，而prototype这个对象本身里面又有一个属性constructor，而这个属性，又指向了函数本身

    alert(SuperType.prototype) //object
    alert(SuperType.prototype.constructor) //弹出函数本身function SuperType(){}

　　1、基本原型

    function Person(){ }  
    Person.prototype.name = "Nicholas"; 
    Person.prototype.age = 29; 
    Person.prototype.job = "Software Engineer"; 
    Person.prototype.sayName = function(){     
        alert(this.name); 
    };  

　　　　这种方式只是说明原型的道理，实际使用中很少把属性写在原型中  

　　2、 更简单的方式

    function Person(){ } 
 
    Person.prototype = {     
        name : "Nicholas",     
        age : 29,     
        job: "Software Engineer",     
        sayName : function () {         
            alert(this.name);     
        } 
    }; 

　　　　这种方式只是上面方式的简单写法，通过对象字面量直接写完所有属性。效果和上面的写法是一样的，只是写法不一样。  

　　　　但是直接全部把属性和方法全部写在原型中，这并不现实，看下面的列子: 

    　　function Person(){ }
  
   　　 Person.prototype = {     
        　　constructor: Person,     
        　　name : "Nicholas",     
        　　age : 29,     
        　　job : "Software Engineer",     
        　　friends : ["Shelby", "Court"],     
        　　sayName : function () {         
            　　alert(this.name);     
        　　} 
    　　}; 
 
    　　var person1 = new Person(); 
    　　var person2 = new Person();  
    　　person1.friends.push("Van");  
    　　alert(person1.friends);    //"Shelby,Court,Van" 
    　　alert(person2.friends);    //"Shelby,Court,Van" 
    　　alert(person1.friends === person2.friends);  //true  

　　　　上面的列子很容易看出，将属性写在原型中的问题,列子中的friends是个数组，引用数据类型在person1中修改了friends,添加了一个条数据之后，可以看到person1和person2对象的friends都发生了改变，这其实很好理解，因为prototype对象本身就是共享的，数组又是属于引用类型，改变了一个，其他的都会发生改变。

　　　　所以，在实际中使用的更多的方法是构造函数与原型结合的方式 

　　3、 构造函数与原型结合的方式

    function Person(name, age, job){     
        this.name = name;     
        this.age = age;     
        this.job = job;     
        this.friends = ["Shelby", "Court"]; 
    }  
    Person.prototype = {     
        constructor : Person,   //记得写这句代码，作用是防止内存泄露    
        sayName : function(){         
            alert(this.name);     
        } 
    } 

    var person1 = new Person("Nicholas", 29, "Software Engineer"); 
    var person2 = new Person("Greg", 27, "Doctor");  
    person1.friends.push("Van"); 
    alert(person1.friends);    //"Shelby,Count,Van" 
    alert(person2.friends);    //"Shelby,Count" 
    alert(person1.friends === person2.friends);    //false 
    alert(person1.sayName === person2.sayName);    //true   

　　　　这里就可以看到，friends的属性在两个对象中就算改变了其中一个，并不会对另外一个产生影响。这种构造函数加原型的混成模式，是目前使用率，认可率最高的一种自定义类型的方式，所以，一般情况下，我们定义自定义类型默认都使用这种模式  

　　4、 动态原型模式

　　　　这种模式只是上面模式的变种，对于一些习惯书写面向对象语言的程序员来说，一个类要分开两个部分来写，是非常不习惯的，所以，就有了动态原型模式，其实无非就是，把之前分开两部分写的内容，全部提到函数中，加上判断就行了

    function Person(name, age, job){  
        //属性  
        this.name = name;     
        this.age = age;     
        this.job = job; 
        //方法  
        if (typeof this.sayName != "function"){              
            Person.prototype.sayName = function(){             
                alert(this.name);         
            };              
        } 
    }  

    var friend = new Person("Nicholas", 29, "Software Engineer"); 
    friend.sayName();  

　　　　　　注意上面的判断，这种方式只有在sayName函数不存在的情况下，才会将它添加到原型中，如果sayName函数已经存在，那么这段代码就不会再运行，而且就算有很多方法的话，if语句也不用全部判断，只是需要判断一个就行了。

　　　　　　这样的写法，对于java或者C#程序员相对来说感官上比较容易接受，而且写法也没有任何缺陷。但是，有一点不算是缺陷的缺点，javascript是一门动态语言，也就是说，属性和方法是随时可以添加的，如果全部写在构造函数里面去，反而看起来不是那么的灵活。所以，一般情况下，还是该使用构造函数与原型的混合模式

四、 Prototype模式的验证方法

　　为了配合prototype属性，Javascript定义了一些辅助方法

　　1、 isPrototypeOf() ： 这个方法用来判断，某个proptotype对象和某个实例之间的关系。　　　　

　　　　function Cat(name,color){
        　　this.name = name;
        　　this.color = color;
    　　}
    　　Cat.prototype.type = "猫科动物";
    　　Cat.prototype.eat = function(){alert("吃老鼠")};  
    　　var cat1 = new Cat("大毛","黄色");
    　　var cat2 = new Cat("二毛","黑色");

　　　　alert(Cat.prototype.isPrototypeOf(cat1)); //true    判断 cat1 对象是否是 prototype原型  
　　　　alert(Cat.prototype.isPrototypeOf(cat2)); //true    判断 cat2 对象是否是 prototype 原型

　　2、 hasOwnProperty() ：用来判断某一个属性到底是本地属性，还是继承自prototype对象的属性。　　　　

    　　function Cat(name,color){
        　　this.name = name;
        　　this.color = color;
    　　}
    　　Cat.prototype.type = "猫科动物";

　　　　alert(cat1.hasOwnProperty("name")); // true    name属性是本地属性 
    　　alert(cat1.hasOwnProperty("type")); // false   type 属性是继承prototype对象的属性

　　3、 in运算符

　　　　　　in运算符可以用来判断，某个实例是否含有某个属性，不管是不是本地属性。 

    　　　　alert("name" in cat1); // true
    　　　　alert("type" in cat1); // true  

　　　　　　in运算符还可以用来遍历某个对象的所有属性。  

    　　　　for(var prop in cat1) { 
        　　　　alert("cat1["+prop+"]="+cat1[prop]); 
    　　　　}

五、 JavaScript高级程序设计书中对与原型的描述和说明  　　

    function Person(){ }  //创建Person构造函数
    Person.prototype.name = "Nicholas";  //创建共享属性name 
    Person.prototype.age = 29;  //创建共享属性age 
    Person.prototype.job = "Software Engineer";   //创建共享属性job 
    Person.prototype.sayName = function(){     //创建共享函数sayName
       alert(this.name); 
　　}
    
    //分别创建了person1和person2,里面都有sayName函数，并且弹出的值都是一样
    var person1 = new Person(); 
    person1.sayName();   //"Nicholas"  
    var person2 = new Person();
    person2.sayName();   //"Nicholas"  
    alert(person1.sayName == person2.sayName);  //true   

　　　　

　　　　通过上面的图，可以看到，person1和person2，他们内部都有一个指向Person.prototype的指针，可以通过原型的isPrototype方法测试一下 

    　　alert(Person.prototype.isPrototypeOf(person1));  //true
    　　alert(Person.prototype.isPrototypeOf(person2));  //true
    　　function User(){};
    　　var person3 = new User();
    　　alert(Person.prototype.isPrototypeOf(person3));  //false  不是prototype原型对象
    　　alert(User.prototype.isPrototypeOf(person3));  //true     是prototype原型对象

　　　　 数组操作的很多方法（比如concat、join、push）应该也是在prototype属性中定义的。 
　　　　实际上，JavaScript所有的固有数据类型都具有只读的prototype属性（这是可以理解的：因为如果修改了这些类型的prototype属性，则哪些预定义的方法就消失了）， 但是我们可以向其中添加自己的扩展方法。

    　　// 向JavaScript固有类型Array扩展一个获取最小值的方法
        Array.prototype.min = function() {
            var min = this[0];
            for (var i = 1; i < this.length; i++) {
                if (this[i] < min) {
                    min = this[i];
                }
            }
            return min;
        };
        
        // 在任意Array的实例上调用min方法
        console.log([1, 56, 34, 12].min());  // 1 

　　注意：这里有一个陷阱，向Array的原型中添加扩展方法后，当使用for-in循环数组时，这个扩展方法也会被循环出来。

　　　　下面的代码说明这一点（假设已经向Array的原型中扩展了min方法）：  　　　

    　　var arr = [1, 56, 34, 12];
        var total = 0;
        for (var i in arr) {
            total += parseInt(arr[i], 10);
        }
        console.log(total);   // NaN  

　　　　解决方法也很简单：

    　　var arr = [1, 56, 34, 12];
        var total = 0;
        for (var i in arr) {
            if (arr.hasOwnProperty(i)) {
                total += parseInt(arr[i], 10);
            }
        }
        console.log(total);   // 103

六、 constructor

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

　　例：　　

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

七、 对象的 __proto__ 隐式原型

　　 上面我们创建了两个对象,person1和person2,这两个对象，也都指向了Person构造函数的原型,这是因为每个对象都有一个隐藏的属性“__proto__”，这个属性引用了创建这个对象的函数的prototype。　　 即：person1.__proto__ === Person.prototype  
　　 这个__proto__是一个隐藏的属性，javascript不希望开发者用到这个属性值，有的低版本浏览器甚至不支持这个属性值。

　　用它的代码如下：

    console.log(Object.prototype);
    var obj = new Object();
    console.log(obj.__proto__);

　　你会发现打印了相同的内容:

　　　　

　　　　obj这个对象本质上是被Object函数创建的，因此obj.__proto__=== Object.prototype。可以用一个图来表示。