摘要：就是通過調用構造函數而創建的那個對象實例的原型對象。構造函數模式可以創建自定義引用類型，可以像創建內置對象實例一樣使用操作符。

簡單數據類型：Undefined、Null、String、Number、Boolean、Symbol
復雜數據類型：Object 
// Undefined：聲明，但未初始化
// Null：空對象指針

typeof操作符（檢測基本數據類型）:

typeof的返回值有哪些：
1. undefined  // 聲明和未初始化的變量，使用typeof都會返回Undefined
2. boolean
3. string
4. number
5. object  // 當是object、null、array時
6. function // 函數是對象，不是一種數據類型，因為特殊，typeof把它從對象中區分出來。typeof 正則也返回function)

typeof 的用途是檢測基本數據類型，檢測引用類型數的值時，用instanceof

instanceof操作符（確定實例和原型之間關系）：

如果變量是給定引用類型的實例，instanceof操作符就會返回true
例如：

person instanceof Object  
arr instanceof Array  
pattern instanceof RegExp  

（經典問題）判斷一個對象是不是數組：

value instanceof Array

Array.isArray(value)

Object.prototype.toString.call(value) // [object Array]

function createPerson(name, age) {
    var o = new Object()     // 顯示地創建對象
    o.name = name
    o.age = age
    o.getName = function () {
        console.log(this.name)
    }
    return o      // 最后需要return
}

其實就是寫了一個函數，每次創建對象就是調用這個函數。

優點：工廠函數解決了創建多個類似對象的問題  
缺點：沒有解決對象識別問題（即怎樣知道一個對象的類型 constructor）

構造函數可以創建特定類型的函數，像Object、Array這樣的原生構造函數。我們可以創建自定義的構造函數

function Person(name, age) {
    this.name = name
    this.age = age
    this.getName = function() {
        console.log(this.name)
    }
}

var person1 = new Person("zhangsan", 18)
var person2 = new Person("lisi", 20)

new 操作符做了什么：
1.創建一個新對象
2.將構造函數的作用于賦給新對象（因此this就只想新對象）
3.執行構造函數中的代碼（為這個新對象添加屬性）
4.返回新對象  

person1和person2分別保存著Person的一個不同實例，這兩個對象都有一個constructor（構造函數）屬性，該屬性指向Person

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

對象的constructor屬性最初是用來標識對象類別的。檢測對象類型還是用instanceof更靠譜(++確定實例和原型之間關系++)

person1 instance Person //true        
person1 instance Object //true

構造函數還可以在另一個對象的作用域中調用

var o = new Object()
Person.call(o, "xiaoming", 12)  // 在o的作用于調用Person構造函數，o就擁有了Person所有的屬性和方法。
o.getName()   // "xiaoming"

call()和apply()的第一個參數是誰，就是在誰的作用于中調用構造函數。

優點：（解決了對象識別問題）創建自定義的構造函數意味著將來可以將它的實例標識為一種特定的類型（Person類），這也是構造函數模式勝過工廠模式的地方  
缺點：構造函數的每個方法，都要在每個實例上重新創建一遍。因此不同實例上的同名函數不相等。

person1.getName == person2.getName   // false

先理解一些概念：
我們創建的每個函數(例如構造函數)都有一個prototype（原型）屬性，這個屬性是一個指針，指向一個對象(函數的原型對象)，這個對象包含所有實例共享的屬性和方法。prototype就是通過調用構造函數而創建的那個對象實例的原型對象。使用原型對象的好處是可以讓所有對象實例共享它所包含的屬性和方法。
例如：給構造函數Person的原型添加屬性和方法，那實例也會共享這些屬性和方法。

function Person() {}
Person.prototype.name = "zhangsan"
Person.prototype.getName = function() {console.log(this.name)}
var person1 = new Person()
person1.getName()   // "zhangsan"

每個函數都有一個prototype屬性，指向該函數的原型對象。而原型對象又有一個constructor(構造函數)屬性，這個屬性是一個指向prototype屬性所在函數的指針。

例如：Person.prototype.constructor 指向 Person    

當調用構造函數創建一個實例，該實例的內部將包含一個指針_proto_，指向構造函數的原型對象。這個連接存在于實例與構造函數的原型對象之間，而不是存在于實例和構造函數之間。

Person.prototype.constructor-->Person      
實例person1._proto_-->Person.prototype

Person.prototype.isPrototypeOf(person1)  //true
Object.getPrototypeOf(person1) == Person.prototype  //true

hasOwnProperty和in:

hasOwnProperty檢測屬性存在于實例，還是原型上。只有屬性值存在于實例時，才返回true
in操作符無法檢測屬性存在于實例還是原型上。只要通過對象能訪問到屬性值，就返回true

function Person() {}
Person.prototype.name = "zhangsan"
var person1 = new Person()
person1.sex = "男"

person1.hasOwnProperty("name")  //false
person1.hanOwnProperty("sex")  //true
name in person1  //true
sex in person1  // true

判斷屬性僅存在于原型：

function(obj, name) {
    return !obj.hasOwnProperty(name) && (name in obj)
}

for in和Object.keys

for in // 實例和原型上所有可枚舉的屬性（返回的是所有能夠通過對象訪問的，可枚舉的屬性）   
Object.keys // 僅實例上可枚舉的屬性 

重寫原型(重新設定constructor)：

Person.prototype = {
    constructor: Person,
    name: "zhangsan",
    getName: function() {
        console.log(this.name)
    }
}

優點：共享函數，不需要每次創建實例都重新創建同名函數。  
缺點：屬性的共享

創建自定義類型最常用的方式，使用最廣范、認可度最高
集兩種模式之長：構造函數模式用于定義實例屬性，原型模式用于定義方法和共享的屬性。這樣每個實例都有自己的一份實例屬性副本，但同時又共享著對方法的引用，最大限度地節省了內存。

5. 動態原型模式

6. 寄生構造函數模式

7. 穩妥構造函數模式

在沒有類的情況下，可以采用以下方式創建對象。

工廠模式：使用簡單的函數創建對象，為對象添加屬性和方法，然后返回對象。這個模式后來被構造函數模式所取代。

構造函數模式：可以創建自定義引用類型，可以像創建內置對象實例一樣使用new操作符。不過構造函數模式也有缺點，即他的每個成員都無法得到復用，包括函數。由于函數可以不局限于任何對象，因此沒有理由不在多個對象間共享。

原型模式：使用構造函數的prototype屬性來指定那些應該共享的屬性和方法。組合使用構造函數模式和原型模式時，使用構造函數定義實例屬性，使用原型定義共享的屬性和方法。

主要依靠原型鏈來實現繼承

原型鏈的主要思想：利用原型讓一個引用類型繼承另一個引用類型的屬性和方法

先回顧下構造函數、原型和實例的關系：
每一個構造函數都有一個原型對象（prototype），原型對象都包含一個指向構造函數的指針(constructor)，而實例都包含一個指向原型對象的內部指針。
那么，假如我們讓原型對象等于另一個類型的實例：

function SuperType() {
    this.type = true
}
SuperType.prototype.getSuperValue = function() {
    return this.type
}
function SubType() {
    this.subtype = false
}
// 繼承了SuperType
SubType.prototype = new SuperType()   //實例賦值給原型的方式
SubType.prototype.getSubValue() {
    return this.subtype
}
var instance = new SubType()
console.log(instance.getSuperValue())  // true

以上定義了兩個類型：SuperType和SubType。每個類型分別有一個屬性和方法。
SubType繼承了SuperType，而繼承是通過創建SuperType實例，并將該實例賦給SubType.prototype來實現的（以一個新類型的實例重寫原型對象）。因此，原來存在于SuperType的實例中的所有屬性和方法，現在也存在于SubType.prototype中了。
最終：instance指向SubType的原型，SubType的原型又指向SuperType的原型

當訪問實例屬性時，首先在示例中搜索該屬性，如果沒找到該屬性，則會繼續搜索實力的原型，如果還沒找到，就沿著原型鏈繼續往上找。

原型鏈的問題：

原型屬性會被所有實例所共享。此方法實現繼承，原型實際上變成了另一個類型的實例。SuperType的屬性就變成了SubType原型上的屬性了，就會被SubType的實例instance1、instance2等所繼承。
在創建子類型實例時，不能向超類型實例傳遞參數。

因此實際中很少多帶帶使用原型鏈。

function SuperType() {
    this.colors = ["red", "blue"]
}
function SubType() {}

SubType.prototype = new SuperType()  // 繼承了SuperType

var instance1 = new SubType()
instance1.colors.push("black")
console.log(instance.coloes)  // "red", "blue", "black"

var instance2 = new SubType()
console.log(instance2.colors)  // "red", "blue", "black"

基本思想： 在子類型構造函數內部調用超類型構造函數

函數只不過是在特定環境中執行代碼的對象，因此通過使用apply()和call()方法也可以在(將來)新建的對象上執行構造函數。

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

var instance2 = new SubType()
console.log(instance2.colors)  //"red", "blue"

通過使用call()方法或者apply()方法，我們實際上是在（將來）新創建的SubType實例的環境下調用SuperType構造函數。

傳遞參數：

function SuperType(name) {
    this.name = name
}
function SubType() {
    // 繼承了SuperType,同時還傳遞了參數
    SuperType.call(this, "zhangsan")
    this.age = 20
}
var instance = new SubType()
console.log(instance.name)   // zhangsan
console.log(instance.age)    // 20

缺點：和構造函數模式存在一樣的問題，函數無法復用。

原型鏈和借用構造函數的技術結合到一塊,發揮兩者之長的繼承模式

基本思想：使用原型鏈實現對原型屬性和方法的繼承，通過借用構造函數來實現對實例屬性的繼承。這樣既通過在原型上定義方法實現了函數的復用，又能夠保證每個函數都有自己的屬性。

function SuperType(name) {
    this.name = name
    this.color = ["red", "blue"]
}
SuperType.prototype.getName = function() {
    console.log(this.name)
}

function SubType(name, age) {
    SuperType.call(this, name)  // 繼承屬性
    this.age = age
}
SubType.prototype.getAge = function() {
    console.log(this.age)
}

SubType.prototype = new SuperType()  // 繼承方法
SubType.prototype.constructor = SubType

var instance1 = new SubType("zhangsan", 18)
instance1.colors.push("black")
console.log(instance1.colors)  // "red", "blue", "black"
console.log(instance1.getName)  // "zhangsan"
console.log(instance1.getAge)   // 18

var instance2 = new SubType("lisi", 20)
console.log(instance2.colors)   //  "red", "blue"
console.log(instance2.getName)  // "lisi"
console.log(instance2.getAge)  // 20

4. 原型式繼承

Object.create()

5. 寄生式繼承

javascript主要是通過原型鏈實現繼承。原型鏈的構建是通過將一個類型的實例賦值給另一個構造函數的原型實現的。這樣，子類型能夠訪問超類型的所有屬性和方法。原型鏈的問題是對象實例共享所有繼承的屬性和方法，因此不適合多帶帶使用。解決這個問題的技術是借用構造函數，即在子類型構造函數的內部調用超類型構造函數。這樣就可以做到每個實例都有自己的屬性，同時還能保證只是用構造函數模式來定義類型。使用最多的繼承模式是組合繼承，這種模式使用原型鏈繼承共享的屬性和方法，而通過借用構造函數繼承實例屬性。

    1. class關鍵字
    2. 定義屬性：constructor(xxx) { this.xxx = xxx }
    3. 定義方法，方法之間不需要“;”

class Person{                   // 使用class，而不是function
    constructor(name, age=18) { // 類的傳參
        this.name = name        // 定義此類的屬性
        this.age = age
    }
    introduce() {                // 定義方法
        return `我叫${this.name}，今年${this.age}歲`
    }
    sayName() {
        console.log(this.name)
    }
    sayAge() {
        console.log(this.age)
    }
}
const me = new Person("張三", 20)
console.log(me.introduce())

class Coder extends Person{
    constructor(name, age, job="Html") {  // 繼承父類屬性，并新加屬性
        super(name, age) // 必須傳參；子類必須在constructor中調用super，否則報錯（因為子類沒有自己的this對象，而是繼承父類的this對象并對其加工，如果不調用super，子類得不到this對象）
        this.job = job
    }
    showJob() { // 子類的新方法
        console.log(this.job)
    }
}
// 調用
const coder1 = new Coder("李四", 22, "js")
coder1.sayName()
coder1.showJob()