摘要：深入理解原型與繼承看過不少書籍，不少文章，對于原型與繼承的說明基本上讓人不明覺厲，特別是對于習慣了面向對象編程的人來說更難理解，這里我就給大家說說我的理解。

看過不少書籍，不少文章，對于原型與繼承的說明基本上讓人不明覺厲，特別是對于習慣了面向對象編程的人來說更難理解，這里我就給大家說說我的理解。

首先JavaScript是一門基于原型編程的語言，它遵守原型編程的基本原則：

所有的數(shù)據都是對象（javascript中除了字符串字面量、數(shù)字字面量、true、false、null、undefined之外，其他值都是對象！）

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

對象會記住它的原型（JavaScript中通過隱藏的__proto__屬性）

如果對象無法響應某個請求，它會把該請求委托給它自己的原型

這么說來，JavaScript一定有一個根對象，所有的對象的最終原型都將是它，它就是Object.prototype（有的人說跟對象是null，因為Object.prototype.__proto__為null），Object.prototype也是一個對象，它是一個空的對象。（記住一點：所有的原型都是對象，但不是函數(shù)，雖然函數(shù)也是對象，Object其實就是一個函數(shù)，而Object.prototype是一個對象）

以下代碼創(chuàng)建空對象：

var obj1 = new Object();
var obj2 = {};
Object.getPrototypeOf(obj1) === Object.prototype; //true
Object.getPrototypeOf(obj2) === Object.prototype; //true

我們再來看下以下代碼：

function Book(name){
    this.name = name;
}
Book.prototype.getName = function(){
    return this.name;
}
Book.num = 5;
var book1 = new Book("javascript");
book1.getName(); //javascript
Object.getPrototypeOf(book1) === Book.prototype; //true

我們通常說，使用了new Book()來創(chuàng)建了Book的實例book1，但是JavaScript并沒有類的概念，這里的Book本質上只是一個函數(shù)而已，如果用new則把它當著構造函數(shù)對待，那么var book1 = new Book("javascript)是怎么個執(zhí)行過程呢？在這之前，我們來先看下Function與Object的關系

這里有張圖：來源于javascriptcn

console.log(Function); //Function 函數(shù)
console.log(Function.constructor); //Function 函數(shù)
console.log(Function.__proto__); //function(){} 空函數(shù)
console.log(Function.__proto__.__proto__);//{} 空對象，即Object.prototype
console.log(Function.prototype); //function(){} 空函數(shù)
console.log(Function.constructor.prototype); //function(){} 空函數(shù)

console.log(Object); //function Object(){[native code]} Object是個函數(shù)
console.log(Object.__proto__); //function(){} 空函數(shù)
console.log(Object.prototype); //{} 空對象
console.log(Object.constructor); //Function 函數(shù)
console.log(Object.constructor.prototype); //function(){} 空函數(shù)

以上測試說明什么？

說明了內置函數(shù)Function以它自身為構造函數(shù)，且以它自身為原型，這個原型是個空函數(shù)；

Object是個函數(shù)，Object是以內置函數(shù)Function為構造函數(shù)的，它自己的原型Object.prototype是個空對象

我總結了這么個東西：在JavaScript中，最原始的東西有兩個，就是function(){}空函數(shù) 和 {}空對象，但它們都有內置的屬性、方法，所有的JS對象都是基于它們創(chuàng)建出來的；

Function和Object就像是女媧和伏羲，Object提供種子(Object.prototype)，F(xiàn)unction負責繁衍(Function.prototype)。Object的實例是由Object.prototype提供的種子經過Function.prototype(function(){} 空函數(shù))打造出來的。Object.prototype這個基因會被一直繼承下去，并一代一代增強。

每一個函數(shù)都有一個原型對象(prototype)和隱藏的__proto__屬性，函數(shù)的__proto__屬性指向Function.prototype，而原型對象(prototype)是一個對象，符合以下第2點(也有構造函數(shù)constructor和隱藏的__proto__屬性)；

每一個對象都有一個構造函數(shù)(constructor)和隱藏的__proto__屬性，constructor自然指的是它的構造函數(shù)，而__proto__指向的是它的構造函數(shù)的原型對象prototype，而對象的原型prototype對象同時又包含了該對象構造函數(shù)、還具有自己的__proto__屬性；

通過__proto__屬性，每個對象和函數(shù)都會記住它的原型，這樣就形成了原型鏈；

console.log(Book); //Book函數(shù)自身
console.log(Book.__proto__); //function(){} 空函數(shù)
console.log(Book.prototype); //Book的原型對象，包含了構造函數(shù)constructor、__proto__
console.log(Book.prototype.__proto__); //{} 等于Object.prototype
console.log(Book.prototype.constructor); //Book函數(shù)自身

console.log(Book.constructor); //Function函數(shù)
console.log(Book.constructor.prototype); //function(){} 空函數(shù)（Function函數(shù)的原型）
console.log(Book.__proto__.__proto__); //{} 等于Object.prototype

每一個函數(shù)都是通過Function構造出來的，函數(shù)的原型屬性__proto__指向Function.prototype，而函數(shù)的原型對象prototype是代表著自身的對象，它的__proto__屬性指向Object.prototype，它的constructor屬性默認指向它自己構造函數(shù)(也可改為別的函數(shù)，如：Book.prototype.constructor = Person;)。

console.log(book1); //Book { name: "javascript" }
console.log(book1.__proto__); //指向Book.prototype對象
console.log(book1.prototype); //undefined
console.log(book1.constructor); //指向Book函數(shù)
console.log(book1.constructor.prototype); //Book.prototype對象

所以，我們通常說‘一個對象的原型’其實是不準確的，應該是‘一個對象的構造器的原型’，且對象是把它無法響應的請求委托給它的構造器的原型順著原型鏈往上傳遞的。

現(xiàn)在來講解一下var book1 = new Book("javascript)的執(zhí)行過程，是這樣：new先通過Function.prototype從Object.prototype克隆一個空對象，然后將空對象的構造函數(shù)constructor指定為Book，并將該空對象的__proto__屬性指向它的構造函數(shù)的原型Book.prototype，之后通過Book構造函數(shù)對這個空對象進行賦值操作，最后將這個對象返回給變量book1。

我們再看如下代碼：

var obj = {name: "Sufu"};
var Person = function(){};
Person.prototype = obj;
var a = new Person();
console.log(a.name); //Sufu

這段是這樣執(zhí)行的：

首先嘗試查找對象a的name屬性，找不到，執(zhí)行第2步

將查找name屬性的這個請求委托給a的構造器的原型，a.__proto__記錄的是Person.prototype，Person.prototype.__proto__記錄的是obj

在對象obj中查找name，找到并返回它的值給a，假如還找不到，它就通過obj.__proto__找到Object.prototype，而Object.prototype.__proto__為null，所以找不到就返回undefined。

總之，對象、函數(shù)都有一個隱藏的__proto__屬性，這個屬性就是原型鏈上的環(huán)，一環(huán)扣一環(huán)，從而形成了原型鏈！

好了，就介紹到這里了，以上是個人的理解，有不對的地方歡迎指出！