摘要：對(duì)象會(huì)記住它的原型給對(duì)象提供了一個(gè)名為的隱藏屬性，某個(gè)對(duì)象的屬性默認(rèn)會(huì)指向它的構(gòu)造器的原型對(duì)象，即。我們通過代碼來驗(yàn)證再來實(shí)際上，就是對(duì)象跟對(duì)象構(gòu)造器的原型聯(lián)系起來的紐帶切記這句話，對(duì)未來理解原型鏈很有幫助。

在許多語言的對(duì)象系統(tǒng)中，封裝數(shù)據(jù)是由語法解析來實(shí)現(xiàn)的，這些語言也許提供了 private、
public、protected 等關(guān)鍵字來提供不同的訪問權(quán)限。例如：java

但在js里面，并沒有提供這些關(guān)鍵字的支持，我們只能通過作用域來模擬實(shí)現(xiàn)封裝性。（ES6 let除外）

var myTest = (function() {
    var _name ="jason";
    return {
        getName: function(){
            return _name;
        }
    }
})()
console.log(myTest.getName()); // 輸出：jason
console.log(_name); // 輸出：_name is not defined

這里，我們定義了一個(gè)自執(zhí)行函數(shù)（什么叫自執(zhí)行函數(shù)？參考這篇文章），函數(shù)內(nèi)部定義了一個(gè)變量_name，函數(shù)return一個(gè)對(duì)象出去（也叫模塊模式），向外部暴露了一個(gè)getName函數(shù)，這里的_name變量就被封裝在了myTest函數(shù)內(nèi)部。

上文說的是封裝數(shù)據(jù)，在js里，不光數(shù)據(jù)可以封裝，還可以封裝實(shí)現(xiàn)、封裝類型，封裝變化等，封裝使得對(duì)象之間的耦合變得松散，對(duì)象之間只通過暴露的 API 接口來通信。

在java中，對(duì)象必須由類創(chuàng)建而來，而在js中，對(duì)象卻是通過原型繼承的方式得來的，在原型編程的思想中，類并不是必需的，對(duì)象未必需要從類中創(chuàng)建而來， 一個(gè)對(duì)象是通過克隆另外一個(gè)對(duì)象所得到的。

原型模式不單是一種設(shè)計(jì)模式，也被稱為一種編程泛型。

從設(shè)計(jì)模式的角度講，原型模式是用于創(chuàng)建對(duì)象的一種模式，如果我們想要?jiǎng)?chuàng)建一個(gè)對(duì)象， 一種方法是先指定它的類型，然后通過類來創(chuàng)建這個(gè)對(duì)象。原型模式選擇了另外一種方式，我們 不再關(guān)心對(duì)象的具體類型，而是找到一個(gè)對(duì)象，然后通過克隆來創(chuàng)建一個(gè)一模一樣的對(duì)象。
原型模式的實(shí)現(xiàn)關(guān)鍵，是語言本身是否提供了 clone 方法。ECMAScript 5 提供了 Object.create 方法，可以用來克隆對(duì)象。代碼如下:

var Plane = function(){ 
    this.blood = 100;
    this.attackLevel = 1;
    this.defenseLevel = 1;
};
var plane = new Plane();
plane.blood = 500;
plane.attackLevel = 10;
plane.defenseLevel = 7;
var clonePlane = Object.create( plane );
console.log( clonePlane ); // 輸出:Object {blood: 500, attackLevel: 10,defenseLevel: 7}

在不支持 Object.create 方法的瀏覽器中，則可以使用以下代碼:

Object.create = Object.create || function( obj ){
    var F = function(){};
    F.prototype = obj;
    return new F(); 
}

所有的數(shù)據(jù)都是對(duì)象。

要得到一個(gè)對(duì)象，不是通過實(shí)例化類，而是找到一個(gè)對(duì)象作為原型并克隆它。

對(duì)象會(huì)記住它的原型。

如果對(duì)象無法響應(yīng)某個(gè)請(qǐng)求，它會(huì)把這個(gè)請(qǐng)求委托給它自己的原型。

這里我們來根據(jù)上面的范式來整理一下js中遵循的規(guī)則

所有的數(shù)據(jù)都是對(duì)象

在js中，除了undefined之外，所有數(shù)據(jù)都是對(duì)象，number、boolean、string 這幾種基本類型數(shù)據(jù)也可以通過“包裝類”的方式變成對(duì)象類型數(shù)據(jù)來處理。那么根據(jù)原型規(guī)則，這些對(duì)象一定有個(gè)根對(duì)象，這個(gè)對(duì)象就是Object.prototype，Object.prototype 對(duì)象是一個(gè)空的 對(duì)象。我們?cè)?JavaScript 遇到的每個(gè)對(duì)象，實(shí)際上都是從 Object.prototype 對(duì)象克隆而來的， Object.prototype 對(duì)象就是它們的原型。

var obj1 = new Object();
var obj2 = {};

console.log( Object.getPrototypeOf( obj1 ) === Object.prototype ); // 輸出:true
console.log( Object.getPrototypeOf( obj2 ) === Object.prototype ); // 輸出:true

要得到一個(gè)對(duì)象，不是通過實(shí)例化類，而是找到一個(gè)對(duì)象作為原型并克隆它

js中克隆是引擎內(nèi)部實(shí)現(xiàn)的，我們不用去關(guān)心他是如何實(shí)現(xiàn)的，我們只要知道使用var obj1 = new Object()或者var obj2 = {}，引擎就會(huì)從Object.prototype克隆一個(gè)對(duì)象出來。

接下來我們看看如何使用new運(yùn)算符得到一個(gè)對(duì)象

var Person = function(name) {
    this.name = name;
    this.getName = function() {
        return this.name;
    }
}

var p = new Person("jason");

console.log(p.name);
console.log(p.getName());
console.log(Object.getPrototypeOf(p) === Person.prototype); // 輸出true

在 JavaScript 中沒有類的概念，這句話我們已經(jīng)重復(fù)過很多次了。但剛才不是明明調(diào)用了newPerson()嗎?

*在這里 Person 并不是類，而是函數(shù)構(gòu)造器，JavaScript 的函數(shù)既可以作為普通函數(shù)被調(diào)用， 7 也可以作為構(gòu)造器被調(diào)用。當(dāng)使用 new 運(yùn)算符來調(diào)用函數(shù)時(shí)，此時(shí)的函數(shù)就是一個(gè)構(gòu)造器。 用
new 運(yùn)算符來創(chuàng)建對(duì)象的過程，實(shí)際上也只是先克隆 Object.prototype 對(duì)象，再進(jìn)行一些其他額 外操作的過程。*

對(duì)象會(huì)記住它的原型

JavaScript 給對(duì)象提供了一個(gè)名為__proto__的隱藏屬性，某個(gè)對(duì)象的__proto__屬性默認(rèn)會(huì)指 向它的構(gòu)造器的原型對(duì)象，即{Constructor}.prototype。
我們通過代碼來驗(yàn)證：

var objA = {
    name: "jason"
}

console.log(objA.__proto__ === Object.prototype); //true

再來

var objB = function(age) {
    this.age = age;
}

var b = new objB();

console.log(b.__proto__ === objB.prototype); //true

實(shí)際上，__proto__就是對(duì)象跟“對(duì)象構(gòu)造器的原型”聯(lián)系起來的紐帶 切記這句話，對(duì)未來理解js原型鏈很有幫助。

如果對(duì)象無法響應(yīng)某個(gè)請(qǐng)求，它會(huì)把這個(gè)請(qǐng)求委托給它的構(gòu)造器的原型

雖然 JavaScript 的對(duì)象最初都是由 Object.prototype 對(duì)象克隆而來的，但對(duì)象構(gòu)造器的原型并不僅限于 Object.prototype 上，可以動(dòng)態(tài)指向其他對(duì)象。

var obj = { name: "sven" };
var A = function(){};

A.prototype = obj;
var a = new A();
console.log(a.__proto__ === obj); //true
console.log(a.name); // 輸出:sven

上面的代碼中，第一行和第二行本沒有任何關(guān)聯(lián)，obj是個(gè)對(duì)象字面量創(chuàng)建的對(duì)象，A是個(gè)空方法，在第三行代碼執(zhí)行之前，obj的__proto__指向Object.prototype，A的prototype指向自身的構(gòu)造器，A.prototype = obj;將引用指向了obj，所以在代碼執(zhí)行完后，對(duì)象a的原型指向obj，雖然a本身沒有name屬性，但原型上擁有name屬性

現(xiàn)在，讓我們來總結(jié)一下js創(chuàng)建對(duì)象的幾種方式：

對(duì)象字面量

var obj = {};

通過對(duì)象構(gòu)造器創(chuàng)建

var Co = function(){};
var obj = new Co();

通過Object.create();創(chuàng)建（ES5以后版本支持）

var Co = function(){};
var obj = Object.create(Co);

通過class創(chuàng)建（ES6以后版本支持）

class An{
    constructor(name){
        this.name = name;
    }
    
    getName() {
        return this.name;
    }
}

class Dog extends Animal { 
    constructor(name) {
        super(name); 
    }
    speak() {
        return "woof";
    } 
}

var dog = new Dog("Scamp");
console.log(dog.getName()); // Scamp
console.log(dog.speak()); // woof

上面的幾種創(chuàng)建對(duì)象的方式有本質(zhì)的區(qū)別，這里先不做詳細(xì)說明，后續(xù)學(xué)完作用域和閉包后再統(tǒng)一說明。