摘要：將構(gòu)造函數(shù)的作用域賦值給新的對象因此指向了這個(gè)新對象。以這種方式定義的構(gòu)造函數(shù)是定義在對象在瀏覽器是對象中的。構(gòu)造函數(shù)在不返回值的情況下，默認(rèn)會返回新對象實(shí)例。在創(chuàng)建子類型的實(shí)例時(shí)，不能向超類型的構(gòu)造函數(shù)中傳遞參數(shù)。

雖然Object構(gòu)造函數(shù)或?qū)ο笞置媪慷伎梢杂脕韯?chuàng)建單個(gè)對象，但是這些方式有明顯的缺點(diǎn)：使用同一個(gè)接口創(chuàng)建很多對象，會產(chǎn)生大量的重復(fù)代碼。為解決這個(gè)問題，人們開始使用工廠模式的一種變體。

工廠模式是軟件工程領(lǐng)域一種廣為人知的設(shè)計(jì)模式，這種模式抽象了創(chuàng)建具體對象的過程。考慮到ECMAScript中無法創(chuàng)建類，開發(fā)人員就發(fā)明了一種函數(shù)，用函數(shù)來封裝以特定接口創(chuàng)建對象的細(xì)節(jié)。

function createPerson(name,age,job){
    var o = new Object();
    o.name = name;
    o.age = age;
    o.job = job;
    o.sayName=function(){
        console.log(this.name)
    }
    return o;
}
var person1 = createPerson("Nicholas",29,"SoftWare");
var person2 = createPerson("gres",27,"Doctor");

函數(shù)cretePerson()能夠根據(jù)接受的參數(shù)來構(gòu)建一個(gè)包含所有必要信息的Person對象。可以無數(shù)次的調(diào)用這個(gè)函數(shù)，而每次它都會返回一個(gè)包含三個(gè)屬性一個(gè)方法的對象。工廠模式雖然解決了創(chuàng)建多個(gè)相似對象的問題，但是卻沒有解決對象識別問題。

function Person(name,age,job){
    this.name = name;
    this.age = age;
    this.sayName = function(){
        console.log(this.name);
    }
}
var person1 = new Person("Nicholas",29,"Software");
var person2 = new Person("gres",24,"Docotor");

在這個(gè)例子中，Person()函數(shù)取代了createPerson()函數(shù)。不同之處：

1.沒有顯式的創(chuàng)建對象。
2.直接將屬性和方法賦給了this對象。
3.沒有return語句。

要創(chuàng)建Person實(shí)例必須使用new操作符。以這種方式調(diào)用構(gòu)造函數(shù)實(shí)際上會經(jīng)歷以下4個(gè)步驟：

1.創(chuàng)建一個(gè)對象。
2.將構(gòu)造函數(shù)的作用域賦值給新的對象（因此this指向了這個(gè)新對象）。
3.執(zhí)行構(gòu)造函數(shù)中的代碼。（為這個(gè)新對象添加屬性）。
4.返回新的對象。

上面的例子：person1和person2分別保存著Person的一個(gè)不同的實(shí)例。 這兩個(gè)對象都有一個(gè)constructor屬性，該屬性指向Person。

person1.constructor == Person//true
person2.constructor == Person//true

person1 instanceof Object;//true
person1 instanceof Person;//true

創(chuàng)建自定義的構(gòu)造函數(shù)意味著將來可以將它的實(shí)例標(biāo)示為一種特定的類型；而這正是構(gòu)造模式勝過工廠模式的地方。（以這種方式定義的構(gòu)造函數(shù)是定義在Global對象（在瀏覽器是window對象）中的）。
構(gòu)造函數(shù)與其它函數(shù)的唯一區(qū)別，就在于調(diào)用它們的方式不同。不過，構(gòu)造函數(shù)畢竟也是函數(shù)，不存在定義構(gòu)造函數(shù)的特殊語法。任何函數(shù)，只要通過new操作符來調(diào)用，那他就可以作為構(gòu)造函數(shù)；任何函數(shù)，如果不通過new運(yùn)算符調(diào)用，那它就跟普通函數(shù)沒有區(qū)別。
構(gòu)造函數(shù)的問題：

使用構(gòu)造函數(shù)的主要問題就是每個(gè)方法都要在每個(gè)實(shí)例上重新創(chuàng)建一遍。在上面的例子中，person1和person2都有一個(gè)名為sayName()的方法，但那兩個(gè)方法不是同一個(gè)Function的實(shí)例。在js中函數(shù)也是對象，因此每定義一個(gè)函數(shù)，也就是實(shí)例化了一個(gè)對象。

function Person(name, age){
    this.name = name;
    this.age = age;
    this.sayName = new Function(console.log(this.name))
}

從這個(gè)角度上看構(gòu)造函數(shù)，更容易明白每個(gè)Perosn實(shí)例都包含一個(gè)不同的Function實(shí)例的本質(zhì)。說明白些，以這種方式創(chuàng)建函數(shù)，會導(dǎo)致不同的作用域鏈和標(biāo)識符解析，但是創(chuàng)建Function新實(shí)例的機(jī)制仍然相同。因此不同實(shí)例上的同名函數(shù)是不相等的。

console.log(person1.sayName==person2.sayName);//false.

然而，創(chuàng)建兩個(gè)完成同樣任務(wù)的Function實(shí)例沒有必要；況且有this對象在，根本不用在執(zhí)行代碼前就把函數(shù)綁定到特定對象上面。因此，可以向下面這樣，通過把函數(shù)定義轉(zhuǎn)移到構(gòu)造函數(shù)外部來解決這個(gè)問題。

function Person(name,age){
    this.name = name;
    this.age = age;
    this.sayName = sayName;
}
function sayName(){
    console.log(this.name)
}
var person1 = new Person("ll",24);
var person2 = new Person("kk",25);

我們創(chuàng)建的每一個(gè)函數(shù)都有一個(gè)prototype屬性，這個(gè)屬性是一個(gè)指針，指向一個(gè)對象，而這個(gè)對象的用途是包含可以有特定類型的所有實(shí)例共享的屬性和方法。

function Person(){}
Person.prototype.name = "ll";
Person.prototype.age = 24;
Person.prototype.sayName=function(){
    console.log(this.name)
}
var person1 = new Person();
var person2 = new Person();

在此我們將sayName()方法和屬性直接添加到Person的prototype屬性中，構(gòu)造函數(shù)變成了空函數(shù)。即使如此，也仍然可以通過調(diào)用構(gòu)造函數(shù)來創(chuàng)建新的對象，而且新的對象還會具有相同的屬性和方法。但與構(gòu)造函數(shù)模式不同的是，新對象的屬性和方法是由所有實(shí)例共享的。
理解原型對象：

無論什么時(shí)候，只要創(chuàng)建了一個(gè)新函數(shù)，就會根據(jù)一定的規(guī)則為該函數(shù)創(chuàng)建一個(gè)prototype屬性，這個(gè)屬性指向函數(shù)的原型對象。在默認(rèn)情況下，所有原型對象都會自動獲得一個(gè)constructor屬性，這個(gè)屬性是一個(gè)指向prototype屬性所在函數(shù)的指針。Person.prototype.constructor指向Person。而通過這個(gè)構(gòu)造函數(shù)，我們還可以繼續(xù)為原型對象創(chuàng)建其它屬性和方法。
創(chuàng)建了自定義構(gòu)造函數(shù)之后，其原型對象默認(rèn)只會得到constructor屬性；至于其它屬性和方法都是從Object對象繼承而來的。當(dāng)調(diào)用構(gòu)造函數(shù)的一個(gè)新實(shí)例后，該實(shí)例內(nèi)部將包含一個(gè)指針，指向構(gòu)造函數(shù)的原型對象。(__proto__);person1和person2都包含一個(gè)內(nèi)部屬性，該屬性僅僅指向了Person.prototype，和構(gòu)造函數(shù)沒有直接的關(guān)系。
每當(dāng)代碼讀取某個(gè)對象的某個(gè)屬性時(shí)，都會執(zhí)行一次搜索，目標(biāo)是具有給定名字的屬性，搜索首先從對象實(shí)例本身開始，如果在實(shí)例中找到了具有給定名字的屬性，則返回該屬性的值；如果沒有找到，則繼續(xù)搜索指針指向的原型對象，如果在原型對象中找到了該屬性，則返回該屬性的值。

function Person(){}
Person.prototype.name = "ll";
Person.prototype.age = 24;
Person.prototype.sayName=function(){
    console.log(this.name)
}
var person1 = new Person();
var person2 = new Person();
person1.name = "kk";
console.log(person1.name)//kk-來自實(shí)例
console.log(person2.name)//ll來自原型

當(dāng)對象實(shí)例添加一個(gè)屬性時(shí)，這個(gè)屬性就會屏蔽原型對象中保存的同名屬性。

原型模式的缺點(diǎn)：

原型中所有屬性是被很多實(shí)例共享的，這種共享對于函數(shù)非常合適。對于那些包含基本值的屬性也說的過去，通過在實(shí)例上添加一個(gè)同名屬性可以隱藏原型中對應(yīng)的屬性。然而對于包含引用類型值的屬性來說，問題就比較突出了：

function Person(){}
Person.prototype={
    constructor:Person,
    name:"kk",
    age:24,
    friends:["ll","jj"],
    sayName:function(){
        console.log(this.name);
    }
}
var person1 = new Person();
var person2 = new Person();
person1.friends.push("aa");
console.log(person1.friends);//ll jj aa
console.log(person2.friends);//ll jj aa
console.log(person1.friends==person2.friends);//true

修改person1.friends引用的數(shù)組，person2同樣會修改。

創(chuàng)建自定義類型的最常見方式，就是組合使用構(gòu)造函數(shù)和原型模式。構(gòu)造函數(shù)模式用于定義實(shí)例屬性，原型模式用于定義共享的屬性和方法。另外這種模式還支持向構(gòu)造函數(shù)穿參數(shù)。

function Person(name,age){
    this.name = name;
    this.age = age;
    this.friends=["kk","ll"];
}
Person.prototype={
    constructor:Person,
    sayName:function(){
        console.log(this.name)
    }
}
var person1 = new Person("nnn",24);
var person2 = new Person("mmm",29);
person1.friends.push("aaa");
console.log(person1.friends);//kk ll aa
console.log(person2.friends);//kk ll 
console.log(person1.friends==person2.friends);//false
console.log(person1.sayName==person2.sayName);//true

function Person(name,age,job){
    var o = new Object();
    o.name = name;
    o.age = age;
    o.job = job;
    o.sayName=function(){
        console.log(this.name);
    }
    return o;
}
var friend = new Person("kk",24,"software");

在這個(gè)實(shí)例中，Person函數(shù)創(chuàng)建了一個(gè)新對象，并以相應(yīng)的屬性和方法初始化該對象，然后又返回了這個(gè)對象。除了使用new操作符并把使用的包裝函數(shù)叫做構(gòu)造函數(shù)之外，這與工廠模式?jīng)]有什么區(qū)別。構(gòu)造函數(shù)在不返回值的情況下，默認(rèn)會返回新對象實(shí)例。而通過在構(gòu)造函數(shù)末尾添加一個(gè)return語句，可以重寫調(diào)用構(gòu)造函數(shù)時(shí)返回的值。
這個(gè)模式可以在特殊的情況下用來為對象創(chuàng)建構(gòu)造函數(shù)。假設(shè)我們想創(chuàng)建一個(gè)具有額外方法的特殊數(shù)組。由于不能直接修改Array的構(gòu)造函數(shù)，因此可以使用這個(gè)模式：

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

關(guān)于寄生構(gòu)造函數(shù)模式，返回的對象與構(gòu)造函數(shù)或則構(gòu)造函數(shù)的原型屬性之間沒有關(guān)系。

所謂穩(wěn)妥對象，指的是沒有公共屬性，而其方法也不引用this的對象。穩(wěn)妥構(gòu)造函數(shù)模式與寄生構(gòu)造函數(shù)模式類似，但是有兩點(diǎn)不同，一是創(chuàng)建對象的實(shí)例方法不引用this，二是不使用new操作符調(diào)用構(gòu)造函數(shù)。

function Person(name,age,job){
    //創(chuàng)建要返回的對象
    var o = new Object();
    //可以在這里定義私有變量和屬性
    //添加方法
    o.sayName=function(){
        console.log(name);
    }
    //返回對象
    return o;
}
var friend = Person("kk",24,"software");
friend.sayName();//kk

每個(gè)構(gòu)造函數(shù)都有一個(gè)原型對象，原型對象都包含一個(gè)指向構(gòu)造函數(shù)的指針，而實(shí)例都包含一個(gè)指向原型對象的內(nèi)部指針。那么，假如我們讓原型對象等于另一個(gè)類型的實(shí)例，此時(shí)的原型對象將包含一個(gè)指向另一個(gè)原型的指針，相應(yīng)的，另一個(gè)原型中也包含著一個(gè)指向另一個(gè)構(gòu)造函數(shù)的指針。

function SuperType(){
    this.property = true;
}
SuperType.prototype.getSuperValue = function(){
    return this.property;
}
function SubType(){
    this.subProperty = true;
}
SubType.prototype = new SuperType();
console.log(SubType.prototype)
SubType.prototype.getSubValue = function(){
    return this.subProperty;
}
var instance = new SubType();
console.log(instance)

以上代碼定義了兩個(gè)類型：SuperType和SubType。每個(gè)類型分別有一個(gè)屬性和一個(gè)方法。它們的主要區(qū)別在于SubType繼承了SuperType，而繼承是通過創(chuàng)建SuperType的實(shí)例，并將該實(shí)例賦值給SubType.prototype實(shí)現(xiàn)的。實(shí)現(xiàn)的本質(zhì)是重寫原型對象，代之以一個(gè)新類型的實(shí)例。
在上面的代碼中，我們沒有使用Subtype默認(rèn)提供的原型，而是給它換了一個(gè)新的原型：這個(gè)新的原型就是SuperType的實(shí)例。于是新原型不僅具有SuperType的實(shí)例所擁有的全部屬性和方法，而且其內(nèi)部還有一個(gè)指針，指向了SuperType的原型。
原型鏈的問題：

1.引用類型值的原型屬性會被所有實(shí)例共享。
2.在創(chuàng)建子類型的實(shí)例時(shí)，不能向超類型的構(gòu)造函數(shù)中傳遞參數(shù)。

在解決原型中包含引用類型值所帶來問題的過程中，開發(fā)人員開始使用一種叫做借用構(gòu)造函數(shù)的技術(shù)。這種技術(shù)的思想相當(dāng)簡單，即在子類構(gòu)造函數(shù)的內(nèi)部調(diào)用超類型構(gòu)造函數(shù)。

function SuperType(){
    this.colors = ["red","blue","pink"]
}
function SubType(){
    //繼承了SuperType
    SuperType.call(this);
}
var instance = new SubType();
instance.colors.push("black");
console.log(instance.colors);//red blue pink black
var instance2 = new SubType();
console.log(instance2.colors);//red blue pink

同時(shí)，借用構(gòu)造函數(shù)有一個(gè)很大的優(yōu)勢，即可以在子類構(gòu)造函數(shù)中向超類型構(gòu)造函數(shù)傳遞參數(shù)。

function SuperType(name){
    this.colors = ["red","blue","pink"];
    this.name = name;
}
function SubType(){
    //繼承了SuperType
    SuperType.call(this,"kk");
}
var instance = new SubType();
console.log(instance.name);//kk

借用構(gòu)造函數(shù)的問題：

方法都需要在構(gòu)造函數(shù)中定義，無法復(fù)用。

function SuperType(name){
    this.name = name;
    this.colors=["red","blue","pink"]
}
SuperType.prototype.sayName=function(){
    console.log(this.name);
}
function SubType(name,age){
    //繼承屬性
    SuperType.call(this,name);
    this.age = age;
}
//繼承方法
SubType.prototype = new SuperType();
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge=function(){
    console.log(this.age);
}
var instance1 = new SubType("kk",24);
instance1.colors.push("black");
console.log(instance1.colors);//red blue pink black
instance1.sayName();//kk
instance1.sayAge();//24

var instance2 = new SubType("ll",26);
console.log(instance2.colors);//red blue pink
instance2.sayAge();//26
instance2.sayName();//ll

組合繼承避免了原型鏈和借用構(gòu)造函數(shù)的缺陷，融合了它們的優(yōu)點(diǎn)。

function object(o){
    function F(){};
    F.prototype = o;
    return new F();
}

在object()函數(shù)內(nèi)部，先創(chuàng)建了一個(gè)臨時(shí)性的構(gòu)造函數(shù)，然后將傳入的對象作為這個(gè)構(gòu)造函數(shù)的原型，然后返回了這個(gè)臨時(shí)類型的一個(gè)實(shí)例。從本質(zhì)上講object()對傳入中的對象進(jìn)行了淺復(fù)制。

var Person={
    name:"kk",
    friends:["ll","aa","cc"]
}
var instance1 = object(Person);
instance1.name = "Greg";
instance1.friends.push("dd");
console.log(instance1)

var instance2 = object(Person);
instance2.name = "Linda";
instance2.friends.push("oo");
console.log(instance2)

obejct()會返回一個(gè)新對象，這個(gè)對象將Person作為原型，所以它的原型中包含一個(gè)基本類型值屬性和一個(gè)引用類型值屬性。這就意味著friends不僅是Person的，也同時(shí)被instance1和instance2共享。

寄生式繼承思路和寄生式構(gòu)造函數(shù)和工廠模式類似，即創(chuàng)建一個(gè)僅用于封裝繼承過程的函數(shù)，該函數(shù)在內(nèi)部以某種方式來增強(qiáng)對象，最后返回對象。

function object(o){
    function F(){};
    F.prototype = o;
    return new F();
}

function createAnother(original){
    var clone = object(original);
    clone.sayName=function(){
        console.log(this.name)
    };
    return clone;
}
var Person={
    name:"ll",
    friens:["kk","cc","aaa"]
}
var instance = createAnother(Person);
console.log(instance)
instance.sayName();

組合繼承是js最常用的繼承模式；不過，他也有自己的不足。組合繼承最大的問題就是無論什么情況下，都會調(diào)用兩次超類型構(gòu)造函數(shù)：一次是在創(chuàng)建子類型原型的時(shí)候，另一次是在子類型構(gòu)造函數(shù)內(nèi)部。

function SuperType(name){
    this.name = name;
    this.colors=["red","blue","pink"];
}
SuperType.prototype.sayName=function(){
    console.log(this.name)
}
function SubType(name,age){
    SuperType.call(this,name);//第二次調(diào)用SuperType()
    this.age = age;
}
SubType.prototype = new SuperType()//第一次調(diào)用SuperType()
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge=function(){
    console.log(this.age);
}

所謂寄生式組合繼承，即通過借用構(gòu)造函數(shù)來繼承屬性，通過原型鏈的混成形式來繼承方法。其背后的基本思路：不必為了指定子類型的原型而調(diào)用超類型的構(gòu)造函數(shù)，我們需要的無非是超類型原型的一個(gè)副本而已。本質(zhì)上，就是使用寄生式繼承來繼承超類型的原型，然后將結(jié)果指定給子類型的原型。

function object(o){
    function F(){};
    F.prototype = o;
    return new F();
}
function inheritPrototype(subType,superType){
    var prototype = object(superType.prototype);//創(chuàng)建對象；
    prototype.constructor = subType;//增強(qiáng)對象
    subType.prototype = prototype;//指定對象
}
function SuperType(name){
    this.name = name;
    this.colors = ["red","blue","pink"];
}
SuperType.prototype.sayName=function(){
    console.log(this.name);
}
function SubType(name,age){
    SuperType.call(this,name);
    this.age = age;
}
var aaa = inheritPrototype(SubType,SuperType);
SubType.prototype.sayAge = function(){
    console.log(this.age);
}
var instance = new SubType("kk",24);
console.log(instance)

在沒有類的情況下，可以采用下列模式創(chuàng)建對象。
1.工廠模式，使用簡單的函數(shù)創(chuàng)建對象，為對象添加屬性和方法，然后返回對象。這個(gè)模式后來被構(gòu)造函數(shù)模式所替代。
2.構(gòu)造函數(shù)模式，可以創(chuàng)建自定義引用類型，可以像創(chuàng)建內(nèi)置對象實(shí)例一樣使用new操作符。不過，構(gòu)造函數(shù)也有缺點(diǎn)，即他的每個(gè)成員都無法得到復(fù)用，包括函數(shù)。
3.原型模式，使用構(gòu)造函數(shù)的prototype屬性來指定那些應(yīng)該共享的屬性和方法。組合使用構(gòu)造函數(shù)模式和原型模式，使用構(gòu)造函數(shù)定義實(shí)例的屬性，而使用原型定義共享的屬性和方法。

JavaScript主要通過原型鏈實(shí)現(xiàn)繼承。原型鏈的構(gòu)建是通過將一個(gè)類型的實(shí)例賦值給另一個(gè)構(gòu)造函數(shù)的原型來實(shí)現(xiàn)的。這樣，子類型就能夠訪問超類型的所有屬性和方法，這一點(diǎn)基于類的繼承很相似。原型鏈的問題是對象實(shí)例共享所有屬性和方法，因此不宜多帶帶使用。解決這個(gè)問題的技術(shù)是借用構(gòu)造函數(shù)，即在子類型構(gòu)造函數(shù)內(nèi)部調(diào)用超類型構(gòu)造函數(shù)。這樣就可以做到每個(gè)實(shí)例都具有自己的屬性，同時(shí)還能保證只使用構(gòu)造函數(shù)模式來定義類型。使用最多的繼承模式是組合繼承，這種模式使用原型鏈繼承共享的屬性和方法，而通過借用構(gòu)造函數(shù)來繼承實(shí)例屬性。
1.原型式繼承，可以在不必預(yù)先定義構(gòu)造函數(shù)的情況下實(shí)現(xiàn)繼承，其本質(zhì)是執(zhí)行對給定對象的淺復(fù)制。而復(fù)制得到的副本還可以得到進(jìn)一步的改造。
2.寄生式繼承，與原型式繼承非常相似，也是基于某個(gè)對象或某些信息創(chuàng)建一個(gè)對象，然后增強(qiáng)對象，最后返回對象。為了解決組合繼承模式由于多次調(diào)用超類型構(gòu)造函數(shù)而導(dǎo)致的低效率問題，可以將這個(gè)模式和組合繼承一起使用。
3.寄生組合式繼承，集寄生式繼承和組合繼承的優(yōu)點(diǎn)與一身，是實(shí)現(xiàn)基于類型繼承的最有效方法。