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

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

但在js里面，并沒有提供這些關(guān)鍵字的支持，我們只能通過作用域來模擬實現(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

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

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

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

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

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

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ù)都是對象。

要得到一個對象，不是通過實例化類，而是找到一個對象作為原型并克隆它。

對象會記住它的原型。

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

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

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

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

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

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

要得到一個對象，不是通過實例化類，而是找到一個對象作為原型并克隆它

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

接下來我們看看如何使用new運算符得到一個對象

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 運算符來調(diào)用函數(shù)時，此時的函數(shù)就是一個構(gòu)造器。 用
new 運算符來創(chuàng)建對象的過程，實際上也只是先克隆 Object.prototype 對象，再進行一些其他額 外操作的過程。*

對象會記住它的原型

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

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

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

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

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

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是個對象字面量創(chuàng)建的對象，A是個空方法，在第三行代碼執(zhí)行之前，obj的__proto__指向Object.prototype，A的prototype指向自身的構(gòu)造器，A.prototype = obj;將引用指向了obj，所以在代碼執(zhí)行完后，對象a的原型指向obj，雖然a本身沒有name屬性，但原型上擁有name屬性

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

對象字面量

var obj = {};

通過對象構(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)建對象的方式有本質(zhì)的區(qū)別，這里先不做詳細說明，后續(xù)學(xué)完作用域和閉包后再統(tǒng)一說明。