摘要：創(chuàng)建對象的方法字面量優(yōu)點(diǎn)簡單方便缺點(diǎn)每創(chuàng)建一個對象都要重新寫，且創(chuàng)建多個比較占內(nèi)存工廠模式優(yōu)點(diǎn)改善了字面量方法創(chuàng)建多個相似對象的問題，不需要編寫重復(fù)的代碼缺點(diǎn)沒有解決對象是別的問題，不知道對象的類型是什么構(gòu)造函數(shù)模式優(yōu)點(diǎn)創(chuàng)建并定義了對象類型

1.字面量

// 優(yōu)點(diǎn)：簡單方便
// 缺點(diǎn)：每創(chuàng)建一個對象都要重新寫，且創(chuàng)建多個比較占內(nèi)存
var obj1 = {
    name: "liuhui1"
};
var obj2 = new Object({
    name: "liuhui2"
});
var obj3 = Object.create({
    name: "liuhui3"
});

2.工廠模式

// 優(yōu)點(diǎn)：改善了字面量方法創(chuàng)建多個相似對象的問題，不需要編寫重復(fù)的代碼
// 缺點(diǎn)：沒有解決對象是別的問題，不知道對象的類型是什么
function person () {
    var obj = new Object();
    obj.name = "liuhui4";
    obj.sayName = function () {
      console.log(this.name);
    };
    return obj;
}
var obj4 = person();
console.log(obj4.sayName());

3.構(gòu)造函數(shù)模式

// 優(yōu)點(diǎn)：創(chuàng)建并定義了對象類型的屬性和方法，可以標(biāo)示為特定的類型（自定義構(gòu)造函數(shù)，原生：Object/Array）
// 缺點(diǎn)：方法沒有被共享，每次實(shí)例一個對象都要重復(fù)綁定一個獨(dú)立的方法
function Person (name) {
    this.name = name;
    this.sayName = function () {
        console.log(this.name);
    };
    this.newFun = newFun;
}
// 解決辦法：將方法寫在全局，但是就變成全局方法了跟封裝的觀念相違背了
// 新增代碼
function newFun () {
    console.log("new name: " + this.name);
}
var obj5 = new Person("liuhui5");
console.log(obj5.sayName());

4.原型模式

// 優(yōu)點(diǎn)：將方法封裝到相應(yīng)的原型對象上，私有并實(shí)例可以共享這些屬性和方法
// 缺點(diǎn)：所有屬性和方法都共享了，改變實(shí)例的屬性和方法會影響原型對象上的屬性和方法
function Person1 () {

}
Person1.prototype = {
    constructor: Person1,
    name: "liuhui6",
    sayName: function () {
        console.log(this.name);
    }
};
var obj6 = new Person1();
console.log(obj6.sayName());

5.組合模式（構(gòu)造函數(shù)+原型模式）還沒有完全理解

// 優(yōu)點(diǎn)：構(gòu)造函數(shù)用于定義實(shí)例屬性和方法，原型模式用于共享定義的屬性和方法
function Person2 (name) {
    this.newName = function () {
        console.log(name);
    }
}
Person2.prototype = {
    constructor: Person2,
    name: "liuhui7",
    sayName: function () {
        console.log(this.name);
    }
};
var obj7 = new Person2();
var obj8 = new Person2("liuhui8");

1.借助構(gòu)造函數(shù)實(shí)現(xiàn)繼承

// 缺點(diǎn)：父級構(gòu)造函數(shù)屬性和方法沒有被共享
function Parent1 () {
    this.name = "parent1";
    this.play = [1, 2, 3];
}
function Child1 () {
    Parent1.call(this); // 關(guān)鍵：執(zhí)行父級構(gòu)造函數(shù)，深復(fù)制
    this.type = "child1";
}
Parent1.prototype.say = function () {
    console.log("hello1");
};
console.log(new Child1());
var s1 = new Child1();
var s2 = new Child1();
s1.play.push(4);
console.log(s1.play, s2.play, s1.hasOwnProperty("play"), "test1");

2.借助原型鏈實(shí)現(xiàn)繼承

// 缺點(diǎn)：原型鏈上的屬性和方法是共享
function Parent2 () {
    this.name = "parent2";
    this.play = [1, 2, 3];
}
function Child2 () {
    this.type = "child";
}
Parent2.prototype.say = function () {
    console.log("hello2");
};
Child2.prototype = new Parent2(); // 關(guān)鍵：將子級執(zhí)行父級構(gòu)造函數(shù)實(shí)現(xiàn)繼承，淺復(fù)制
console.log(new Child2(), new Child2().say());
var s3 = new Child2();
var s4 = new Child2();
s3.play.push(4);
console.log(s3.play, s4.play, s3.hasOwnProperty("play"), "test2");

3.組合方式

// 缺點(diǎn)：父級構(gòu)造函數(shù)執(zhí)行了兩遍
function Parent3 () {
    this.name = "parent3";
    this.play = [1, 2, 3];
}
function Child3 () {
    Parent3.call(this); // 關(guān)鍵1
    this.type = "child3";
}
Parent3.prototype.say = function () {
    console.log("hello3");
};
Child3.prototype = new Parent3(); // 關(guān)鍵2
var s5 = new Child3();
var s6 = new Child3();
s5.play.push(4);
console.log(s5, s6, s5.hasOwnProperty("play"), "test");

4.組合方式優(yōu)化1

// 缺點(diǎn)：實(shí)例屬性constructor指向父級構(gòu)造函數(shù)，使用instanceof不能正確判斷對象類型
function Parent4 () {
    this.name = "parent4";
    this.play = [1, 2, 3];
}
function Child4 () {
    Parent4.call(this);
    this.type = "child4";
}
Parent4.prototype.say = function () {
    console.log("hello4");
};
Child4.prototype = Parent4.prototype;
Child4.prototype.constructor = Child4; // 新增代碼，讓實(shí)例指向其真實(shí)的構(gòu)造函數(shù)
var s7 = new Child4();
var s8 = new Child4();
s7.play.push(4);
console.log(s7, s8);
// 判斷是子原型Child4實(shí)例化還是Parent4直接實(shí)例化的
console.log(s7 instanceof Child4, s8 instanceof Parent4); // 判斷不了
console.log(s7.constructor, s8.constructor, s7.hasOwnProperty("play"), "test");

5.組合方式優(yōu)化2

function Parent5 () {
    this.name = "parent5";
    this.play = [1, 2, 3];
}
function Child5 () {
    Parent5.call(this);
    this.type = "child5";
}
Parent5.prototype.say = function () {
    console.log("hello5");
};
Child5.prototype = Object.create(Parent5.prototype);
Child5.prototype.constructor = Child5;
var s9 = new Child5();
var s10 = new Child5();
s9.play.push(4);
console.log(s9 instanceof Child5, s9 instanceof Parent5);
console.log(s9.constructor, s10.constructor, s9.hasOwnProperty("play"), "test11");

構(gòu)造函數(shù)的繼承

非構(gòu)造函數(shù)的繼承