摘要：指向原型對象的構(gòu)造函數(shù)二原型鏈?zhǔn)裁词窃玩溤玩溇褪菍?shí)例對象和原型對象之間的關(guān)系，他們使用來關(guān)聯(lián)。改變指向?qū)崿F(xiàn)繼承創(chuàng)建類創(chuàng)建原型對象每天堅(jiān)持鍛煉創(chuàng)建構(gòu)造函數(shù)函數(shù)就是改變執(zhí)行代碼片段中指向。

   prototype:是一個(gè)函數(shù)的屬性，每個(gè)函數(shù)中都會(huì)有一個(gè)prototype屬性，這個(gè)屬性是一個(gè)指針，指向一個(gè)對象。在JavaScript中原型是一個(gè)prototype對象，用于表示類型之間的關(guān)系。
  

每個(gè)函數(shù)都有一個(gè)prototype屬性，這個(gè)屬性是指向一個(gè)對象的引用，這個(gè)對象稱為原型屬性。

       function Person() {}
      var p = new Person();

原型對象包含實(shí)例共享的方法和屬性，這個(gè)函數(shù)用作構(gòu)造函數(shù)時(shí)調(diào)用，使用new操作符調(diào)用的時(shí)候，新創(chuàng)建的對象會(huì)從原型對象上得到同樣的屬性和方法。
原型作用之一:數(shù)據(jù)共享,節(jié)省內(nèi)存空間
原型作用之二:為了實(shí)現(xiàn)繼承

proto:是一個(gè)對象擁有的內(nèi)置屬性，是js內(nèi)部使用尋找原型鏈的屬性，通過該屬性可以允許使用實(shí)例對象直接訪問原型。
注意，prototype是函數(shù)的內(nèi)置屬性，__proto__是對象的內(nèi)置屬性

        function Person() {}
     var p = new Person();
  // 以前不能直接使用 p直接訪問對象原型
  // 現(xiàn)在有了 __proto__ 后
  // p.__proto__ 也可以直接訪問對象原型
  // 那么 p.__proto__ === Person.prototype

可以訪問原型

由于在開發(fā)中除非特殊要求, 不要使用實(shí)例去修改原型的成員. 因此屬性開發(fā)時(shí)使用較少

調(diào)試過程中非常方便, 可以輕易的訪問原型進(jìn)行查看成員

constructor：屬性返回對創(chuàng)建此對象的函數(shù)的引用。(指向原型對象的構(gòu)造函數(shù))

原型鏈就是實(shí)例對象和原型對象之間的關(guān)系，他們使用__proto__來關(guān)聯(lián)。
圖解：

分析： a._proto_ ==Funciton構(gòu)造函數(shù)的原型對象，其實(shí)原型對象也是一個(gè)實(shí)例化對象，既然是對象，那么他就是用Object來創(chuàng)建的， 既 var obj = new Object();所以Functionde的原型對象._proto_ = = Object構(gòu)造函數(shù)的原型對象

看下面的圖文解讀：

      function Person(name,age){
            this.name = name;
            this.age = age;
        };
        Person.prototype = {
                run:function(){
                    console.log("每天堅(jiān)持鍛煉");
                }
        };
        var person1 = new Person("Tom",20);
        person1.run();// 輸出每天堅(jiān)持鍛煉身體

很顯然，構(gòu)造函數(shù)的原型對象是可以進(jìn)行改變的，改變之后，當(dāng)實(shí)例化對象時(shí)，它的原型對象就是構(gòu)造函數(shù)新指向的對象。

繼承是一種關(guān)系,類(Class)與類之間的關(guān)系,JS中沒有類,但是可以通過構(gòu)造函數(shù)模擬類,然后通過原型來實(shí)現(xiàn)繼承。繼承是為了數(shù)據(jù)共享,js中的繼承也是為了實(shí)現(xiàn)數(shù)據(jù)共享
eg：構(gòu)建一個(gè)類是"人"，他有姓名，性別，年齡等屬性和方法，再構(gòu)建一個(gè)學(xué)生類，他可以繼承人的姓名，性別年齡等屬性，并且他還有屬于他自己的方法，比如：學(xué)習(xí)行為。看下面代碼：

    //定義一個(gè)人的類別
        function Person (name,age,sex) {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }
        Student.prototype = new Person("Tom",20,"man");
        //定義一個(gè)學(xué)生類別
        function  Student(){
                this.s =  function(){
                console.log("學(xué)生的天職就是學(xué)習(xí)");
            }
        }
        //實(shí)例化一個(gè)學(xué)生對象
        var student = new Student();
        student.s();// 學(xué)生的天職就是學(xué)習(xí)
        console.log(student.name);// Tom
        console.log(student.age);// 20
        console.log(student.sex);// man

分析：  實(shí)例化學(xué)生的對象繼承了 Student對象的  方法，并且繼承了  Person 對象的姓名，年齡，性別 屬性。這就是繼承。

看下面的圖文詳解

     // 創(chuàng)建一個(gè)動(dòng)物類別
        function  Animal (weight,color) {
            this.weight = weight;
            this.color = color;
        };
        // 創(chuàng)建一個(gè)狗類
        function Dog(){
            this.bite = function (){
                console.log("咬人");
            };
        };
        Dog.prototype = new Animal("25kg","white");
        //創(chuàng)建一個(gè)二哈(狗的品種)類
        function Erha(){
            this.sayHello = function(){
                console.log("二哈是我們的好朋友，但是讓人討厭的是它會(huì)拆家！");
            }
        }
        Erha.prototype = new Dog();
        // 實(shí)例化一個(gè)對象
        var dog = new Erha();
        dog.bite();// 咬人
        dog.sayHello();// 二哈是我們的好朋友，但是讓人討厭的是它會(huì)拆家！
        console.log(dog.weight);// 25kg
        console.log(dog.color);//white

分析：首先創(chuàng)建一個(gè)Animal構(gòu)造函數(shù)，里面有兩個(gè)屬性，然后在創(chuàng)建一個(gè)Dog構(gòu)造函數(shù)，并改變Dog構(gòu)造函數(shù)的原型對象 既     Dog.prototype = new  Animal("25kg","white");  最后創(chuàng)建Erha對象，再次改變Erha的原型對象，
Erha.prototype = new Dog();   實(shí)例化一個(gè)對象，這時(shí)。這個(gè)實(shí)例化的對象就擁有了Animal的屬性和方法，包括Dog的屬性和方法，這就實(shí)現(xiàn)了繼承，

缺陷： 如果實(shí)例化出來的對象，那么它的屬性初始化值都是一樣的。

     // 創(chuàng)建Person類
        function  Person(name,age,sex){
            this.name = name;
            this.age = age;
            this.sex = sex;
        };
        // 創(chuàng)建原型對象
        Person.prototype.run = function(){
            console.log("每天堅(jiān)持鍛煉");
        }
        // 創(chuàng)建Studet 構(gòu)造函數(shù)
        function Student(name,age,sex,score){
            // call函數(shù)就是改變執(zhí)行代碼片段中this指向。
            // this指的是當(dāng)前函數(shù)
            Person.call(this,name,age,sex);
            this.score = score;
            this.study = function(){
                console.log("學(xué)生的天職就是學(xué)習(xí)");
            }
        };
        // 改變Student的原型對象，下面這句代碼很重要，如果沒有這句代碼會(huì)出現(xiàn)不能繼承父類原型對象的方法，這也是改變this指向繼承的缺陷，所以我們可以采用兩中模式共存的思想進(jìn)行繼承。
        Student.prototype = new Person();
        var stu1 = new Student("Tom",19,"man",80);
        stu1.run();// 每天堅(jiān)持鍛煉
        console.log(stu1.name);// Tom
        console.log(stu1.age);// 19
        console.log(stu1.sex);// man
        console.log(stu1.score);// 80

分析：其實(shí)這個(gè)很簡單，只要你明白this的指向就好明白了，this的指向見我的另一篇文章Js面向?qū)ο蟮诹〗Y(jié)。先分析這個(gè)，首先創(chuàng)建類我就不說了，直接說這個(gè)this指向問題，這里小編用了一個(gè)call()方法，call函數(shù)能夠改變代碼片段的this指向，本例中this指向?yàn)楫?dāng)前函數(shù)，Person(this,name,age,sex)===this.name = name; this.age = age;this.sex = sex;    這下是不是明白了

補(bǔ)充： apply 函數(shù)，這個(gè)函數(shù)也可以實(shí)現(xiàn)改變this指向來完成繼承，見下面的代碼：

       // 創(chuàng)建Person類
        function  Person(name,age,sex){
            this.name = name;
            this.age = age;
            this.sex = sex;
        };
        // 創(chuàng)建原型對象
        Person.prototype.run = function(){
            console.log("每天堅(jiān)持鍛煉");
        }
        // 創(chuàng)建Studet 構(gòu)造函數(shù)
        function Student(name,age,sex,score){
            // call函數(shù)就是改變執(zhí)行代碼片段中this指向。
            // this指的是當(dāng)前函數(shù)
            Person.apply(this,[name,age,sex]);
            this.score = score;
            this.study = function(){
                console.log("學(xué)生的天職就是學(xué)習(xí)");
            }
        };
        // 改變Student的原型對象
        Student.prototype = new Person();
        var stu1 = new Student("Tom",19,"man",80);
        stu1.run();// 每天堅(jiān)持鍛煉
        console.log(stu1.name);// Tom
        console.log(stu1.age);// 19
        console.log(stu1.sex);// man
        console.log(stu1.score);// 80

這里只改變一句代碼：  Person.apply(this,[name,age,sex]);
很明顯可以看出，apply和call的區(qū)別就是  參數(shù)問題，apply的第二個(gè)參數(shù)為數(shù)組，而call為數(shù)據(jù)

補(bǔ)充： bind函數(shù)

bind的作用是將函數(shù)復(fù)制一份并且改變函數(shù)中的this, 并且返回這個(gè)函數(shù)。

見下面的代碼分析：

    function Person(name,age){
            this.name = name;
            this.age = age;
            this.run = function(){
                console.log(this.age);
            }
        }
        var p1 = new Person("Tom",15);
        var p2 = new Person("Jack",19);
        p1.run.bind(p2)();// 19

分析：使用bind函數(shù)時(shí)會(huì)復(fù)制一份函數(shù)，本例子是把 function(){console.log(this.age)}  復(fù)制了一份，并改變了此時(shí)的this 為p2.

說實(shí)話，這節(jié)真的很難懂，我也是略懂一二而已，要想真正的明白，需要慢慢的沉淀，不知道正在學(xué)習(xí)前端的你針對這節(jié)內(nèi)容有什么想法，可以留言告訴我，我們一起努力！