感覺最難的部分就是面向物件了，大學期間學習的是面向過程的c/c++，工作之後也沒有深入瞭解過面向物件，通過這次的學習和回顧，也算是對面向物件有了新的認識。不過，就我在書上學到了結合個人理解隨便說說，很可能有理解錯誤或者不準確的地方。js的物件和其他語言的物件並不完全一樣，可以理解為散列表。物件的每個屬性或方法都有一個名字，而每個名字都對映到一個值。

    首先需要知道一個定義，特性。我覺得可以理解為物件的屬性的屬性，用於描述屬性的各種特徵。可以用來對物件的屬性進行管理，比如屬性資料的讀寫和訪問許可權。但是我看完了之後，覺得這個功能雖然強大，不過目前用不到，以後碰到的時候再補充吧。下面好好講講建立物件和繼承。

一，建立物件

    前面一篇文章提到了建立物件的一些方法，new Object和物件字面量。建立一個物件還行，建立多個的話程式碼量就太多了，所以現在有很多其他的建立物件的方法。

1，工廠模式

    一句話，用函式建立物件。兩句話，建立一個新物件，然後把這個物件指標賦給新變數。

        function createPerson(name, age, job){
            var o = new Object();
            o.name = name;
            o.age = age;
            o.job = job;
            o.sayName = function(){
                alert(this.name);
            };    
            return o;
        }
        
        var person1 = createPerson("Nicholas", 29, "Software Engineer");
        var person2 = createPerson("Greg", 27, "Doctor");
        
        person1.sayName();   //"Nicholas"
        person2.sayName();   //"Greg"
 

    但是這樣建立的話，每個物件的型別都是object，無法識別區別。

2，建構函式模式

    像Object和Array這樣的原生建構函式，可以通過new呼叫來直接建立物件。而我們也可以自定義建構函式，從而自定義物件型別的屬性和方法。

        function Person(name, age, job){
            this.name = name;
            this.age = age;
            this.job = job;
            this.sayName = function(){
                alert(this.name);
            };    
        }
        
        var person1 = new Person("Nicholas", 29, "Software Engineer");
        var person2 = new Person("Greg", 27, "Doctor");
        
        person1.sayName();   //"Nicholas"
        person2.sayName();   //"Greg"
        
        alert(person1 instanceof Object);  //true
        alert(person1 instanceof Person);  //true
        alert(person2 instanceof Object);  //true
        alert(person2 instanceof Person);  //true
        
        alert(person1.constructor == Person);  //true
        alert(person2.constructor == Person);  //true
        
        alert(person1.sayName == person2.sayName);  //false  
 

用new操作符呼叫建構函式實際上經過了四步：（1），建立一個新物件。（2），將建構函式的作用域賦給新物件。（3），執行建構函式的程式碼，給新物件增加屬性。（4），返回新物件。這兩個生成的物件都有一個建構函式屬性constructor，指向建構函式Person。對於建構函式這一類特殊函式，還有值得說明的地方。

首先，建構函式是可以直接呼叫的，直接把屬性賦給window物件。

        function Person(name, age, job){
            this.name = name;
            this.age = age;
            this.job = job;
            this.sayName = function(){
                alert(this.name);
            };
        }
        
        var person = new Person("Nicholas", 29, "Software Engineer");
        person.sayName();   //"Nicholas"
        
        Person("Greg", 27, "Doctor");  //adds to window
        window.sayName();   //"Greg"
        
        var o = new Object();
        Person.call(o, "Kristen", 25, "Nurse");
        o.sayName();    //"Kristen"

其次，建構函式有一個問題就是，如果像上面那麼定義的話，會定義很多sayName函式，但是都是做同一件事情（每次例項建構函式都會執行內部程式碼）。明顯不太好，把方法定義放在函式外部可以解決這個問題。

        function Person(name, age, job){
            this.name = name;
            this.age = age;
            this.job = job;
            this.sayName = sayName;
        }
        
        function sayName(){
            alert(this.name);
        }
        
        var person1 = new Person("Nicholas", 29, "Software Engineer");
        var person2 = new Person("Greg", 27, "Doctor");
        
        person1.sayName();   //"Nicholas"
        person2.sayName();   //"Greg"
        
        alert(person1 instanceof Object);  //true
        alert(person1 instanceof Person);  //true
        alert(person2 instanceof Object);  //true
        alert(person2 instanceof Person);  //true
        
        alert(person1.constructor == Person);  //true
        alert(person2.constructor == Person);  //true
        
        alert(person1.sayName == person2.sayName);  //true    

    不過這樣也有問題，直接打字書上的原話：在全域性作用域中定義的函式實際上只能被某個物件呼叫，這讓全域性作用域有點名不副實。而更讓人無法接受的是，如果物件需要定義很多方法，那麼就要定義很多個全域性函式，於是我們這個定義的引用型別就沒有絲毫的封裝性可言了。好在這些問題都可以通過原型模式解決。

3，原型模式
    我們建立的每個函式都有一個prototype（原型）屬性，這個屬性是一個指標，指向一個物件，而這個物件的用途是包含可以由特定型別的所有例項共享的屬性和方法。實際上，prototype就是原型物件，不必在建構函式中定義物件例項的資訊，而是可以直接把這些資訊新增到原型物件中。

        function Person(){
        }
        
        Person.prototype.name = "Nicholas";
        Person.prototype.age = 29;
        Person.prototype.job = "Software Engineer";
        Person.prototype.sayName = function(){
            alert(this.name);
        };
        
        var person1 = new Person();
        person1.sayName();   //"Nicholas"
        
        var person2 = new Person();
        person2.sayName();   //"Nicholas"
      
        alert(person1.sayName == person2.sayName);  //true
        
        alert(Person.prototype.isPrototypeOf(person1));  //true
        alert(Person.prototype.isPrototypeOf(person2));  //true
        
        //only works if Object.getPrototypeOf() is available
        if (Object.getPrototypeOf){
            alert(Object.getPrototypeOf(person1) == Person.prototype);  //true
            alert(Object.getPrototypeOf(person1).name);  //"Nicholas"
        }

    個人理解，這種方法就是改良工廠方法，相當於把工廠方法中的新建物件和賦值的過程，變成了把原型物件作為原型物件屬性賦給新物件的過程。同時我們這個時候修改例項的屬性時，會在例項下新增屬性。而在我們呼叫例項的屬性時，會先查詢新物件新增加的屬性，然後找找原型物件的屬性。可以通過in，判斷屬性是否存在。可以通過hasOwnProperty()，判斷屬性是在例項還是原型。（就不舉例了）

        function Person(){
        }
        
        Person.prototype.name = "Nicholas";
        Person.prototype.age = 29;
        Person.prototype.job = "Software Engineer";
        Person.prototype.sayName = function(){
            alert(this.name);
        };
        
        var person1 = new Person();
        var person2 = new Person();
        
        person1.name = "Greg";
        alert(person1.name);   //"Greg" ?from instance
        alert(person2.name);   //"Nicholas" ?from prototype

可以直接重寫原型物件，這樣更方便，不過這樣一來，本來從建構函式獲取的原型物件的建構函式屬性就變成Object了，需要重定義一下。

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

        var friend = new Person();
        
        alert(friend instanceof Object);  //true
        alert(friend instanceof Person);  //true
        alert(friend.constructor == Person);  //true
        alert(friend.constructor == Object);  //false

與此同時，重寫原型物件會切斷現有原型和任何之前已經存在的物件例項之間的聯絡；它們引用的仍然是最初的原型。

然而，原型物件方法有一個致命缺點，對於包含引用型別的屬性，修改例項物件會影響原型物件從而影響所有物件。

        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

4，組合使用建構函式模式和原型模式

    講了這麼多有問題的方法，講一個能用而且最常用的方法吧。組合了建構函式模式和原型模式，建構函式模式用於定義例項屬性，原型模式用於定義方法和共享屬性。

        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,Court,Van"
        alert(person2.friends);    //"Shelby,Court"
        alert(person1.friends === person2.friends);  //false
        alert(person1.sayName === person2.sayName);  //true

5.動態原型模式

    這個我看了幾遍都沒看懂，看了知乎上面的一個解釋瞬間明白了。可以注意到第四種組合方法裡面，原型物件是採用重寫方法的，當必須採用字面量方法時，那就會碰到建構函式模式的問題，多次定義相同函式，這個時候加個判斷問題就迎刃而解了。

        function Person(name, age, job){
        
            //properties
            this.name = name;
            this.age = age;
            this.job = job;
            
            //methods
            if (typeof this.sayName != "function"){
            
                Person.prototype.sayName = function(){
                    alert(this.name);
                };
                
            }
        }

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

此外還有寄生建構函式模式和穩妥建構函式模式就不說了。

二，繼承

    繼承和建立有很多類似的地方，但是現在用的少，以後想起來再寫吧。