《Javascript高級程式設計》：創建對象

工廠模式

 1             function createPerson(name,age, job){
 2                 var o = new Object();
 3                 o.name = name;
 4                 o.age = age;
 5                 o.job = job;
 6                 o.sayName = function(){
 7                     alert(this.name);
 8                 };
 9                 return o;
10             }
11             var person1 = createPerson("Nicholas", 29, "Software Engineer");
12             var person2 = createPerson("Greg", 27, "Doctor");
13             console.log(person1);
14             console.log(person2);

優點：解決了創造對象的問題

缺點：沒有解決對象識別的問題 （instanceof -> Object）

構造函數模式

 1     function Person(name,age,job){
 2                 this.name = name;
 3                 this.age = age;
 4                 this.job = job;
 5                 this.sayName = function(){
 6                     alert(this.name);
 7                 }
 8             }
 9             var person1 = new Person("Nicholas", 30, "Software Engineer");
10             console.log(person1);
11             person1.sayName();
12             alert(person1.constructor == Person);
13             alert(person1 instanceof Object);
14             alert(person1 instanceof Person);

優點：解決對象識別的問題 （instanceof -> Object）

缺點：不同實例上的同名函數是不相等的。有this對象在，沒有必要在執行代碼前把函數綁定到特定的對象上來。

原型模式

 1     function Person(){}
 2                 Person.prototype.name = "Nicholas";
 3                 Person.prototype.age = 29;
 4                 Person.prototype.job = "software Engineer";
 5                 Person.prototype.sayName = function(){
 6                     alert(this.name);
 7             }
 8             
 9             var person1 = new Person();
10             person1.sayName();
11             
12             var person2 = new Person();
13             person2.sayName();
14             
15             alert(person1.sayName == person2.sayName);

優點：不同實例上的同名函數是相等的

缺點：引用對象的值是所有實例共用的，不存在自己獨特的屬性

組合使用構造函數和原型模式

 1         function Person(name, age, job){
 2                 this.name = name;
 3                 this.age = age;
 4                 this.job = job;
 5                 this.friends = ["Shelby","Count"];
 6             }
 7             Person.prototype = {
 8                 constructor : Person,
 9                 sayName : function(){
10                     alert(this.name);
11                 }
12             }
13             var person1 = new Person("Nicholas", 29, "Software Engineer");
14             var person2 = new Person("Greg", 27, "Doctor");
15             
16             person1.friends.push("Van");
17             alert(person1.friends);   //S,C,V
18             alert(person2.friends);    //S,C
19             alert(person1.friends  === person2.friends);  // false
20             alert(person1.sayName  === person2.sayName);  //true

優點：同時具有構造函數模式和原型模式的優點

缺點：

動態原型模式

        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() 方法不存在的情況下，才會將它添加的原型中。這段代碼只會在初次調用構造函數時才會執行。

寄生構造函數模式

function SpecialArray() {
            var values = new Array();
            values.push.apply(values, arguments);
            
            values.toPipedString = function(){
                return this.join("|");
                
            };
            return values;
        }
        
        var colors = new SpecialArray("red", "blue", "green");
        alert(colors.toPipedString());        

首先，返回的對象與構造函數或者構造函數與原型屬性之間沒有關係；也就是說，構造函數返回對象與構造函數外部創建的對 象沒有什麼不同。為此不能依賴instanceof操作符來確定對象類型。建議能用其他模式的情況下，不要使用這種模式。

穩妥構造函數模式

    function Person(name, age, job){
            var o = new Object();
            //可以在這裡自定義私有變數和函數
            o.sayName = function(){
                alert(name);
            };
            return o;
        }