概述
JavaScript的所有對象，都有自己的繼承鏈。也就是說，每個對象都繼承另一個對象，該對象稱為“原型”（prototype）對象。只有null除外，它沒有自己的原型對象。
原型對象的重要性在于，如果A對象是B對象的原型，那么B對象可以拿到A對象的所有屬性和方法。Object.getPrototypof方法用于獲取當(dāng)前對象的原型對象。
var p = Object.getPrototypeOf(obj);
上面代碼中，對象p就是對象obj的原型對象。
Object.create方法用于生成一個新的對象，繼承指定對象。
var obj = Object.create(p);
上面代碼中，新生成的obj對象的原型就是對象p。
非標(biāo)準(zhǔn)的__proto__屬性（前后各兩個下劃線），可以改寫某個對象的原型對象。但是，應(yīng)該盡量少用這個屬性，而是用Object.getPrototypeof()和Object.setPrototypeOf()，進(jìn)行原型對象的讀寫操作。
var obj = {};var p = {};obj.__proto__ = p;Object.getPrototypeOf(obj) === p // true上面代碼通過__proto__屬性，將p對象設(shè)為obj對象的原型。
下面是一個實際的例子。
var a = {x: 1};var b = {__proto__: a};b.x // 1上面代碼中，b對象通過__proto__屬性，將自己的原型對象設(shè)為a對象，因此b對象可以拿到a對象的所有屬性和方法。b對象本身并沒有x屬性，但是JavaScript引擎通過__proto__屬性，找到它的原型對象a，然后讀取a的x屬性。
new命令通過構(gòu)造函數(shù)新建實例對象，實質(zhì)就是將實例對象的原型綁定構(gòu)造函數(shù)的prototype屬性，然后在實例對象上執(zhí)行構(gòu)造函數(shù)。
var o = new Foo();// 等同于var o = new Object();o.__proto__ = Foo.prototype;Foo.call(o);
原型對象自己的__proto__屬性，也可以指向其他對象，從而一級一級地形成“原型鏈”（prototype chain）。
var a = { x: 1 };var b = { __proto__: a };var c = { __proto__: b };c.x // 1需要注意的是，一級級向上，在原型鏈尋找某個屬性，對性能是有影響的。所尋找的屬性在越上層的原型對象，對性能的影響越大。如果尋找某個不存在的屬性，將會遍歷整個原型鏈。
this的動作指向
不管this在哪里定義，使用的時候，它總是指向當(dāng)前對象，而不是原型對象。
var o = { a: 2, m: function(b) { return this.a + 1; }};var p = Object.create(o);p.a = 12;p.m() // 13上面代碼中，p對象的m方法來自它的原型對象o。這時，m方法內(nèi)部的this對象，不指向o，而是指向p。
構(gòu)造函數(shù)的繼承
這個小節(jié)介紹，如何讓一個構(gòu)造函數(shù)，繼承另一個構(gòu)造函數(shù)。
假定有一個Shape構(gòu)造函數(shù)。
function Shape() { this.x = 0; this.y = 0;}Shape.prototype.move = function (x, y) { this.x += x; this.y += y; console.info('Shape moved.');};Rectangle構(gòu)造函數(shù)繼承Shape。function Rectangle() { Shape.call(this); // 調(diào)用父類構(gòu)造函數(shù)}// 另一種寫法function Rectangle() { this.base = Shape; this.base();}// 子類繼承父類的方法Rectangle.prototype = Object.create(Shape.prototype);Rectangle.prototype.constructor = Rectangle;var rect = new Rectangle();rect instanceof Rectangle // truerect instanceof Shape // truerect.move(1, 1) // 'Shape moved.'上面代碼表示，構(gòu)造函數(shù)的繼承分成兩部分，一部分是子類調(diào)用父類的構(gòu)造方法，另一部分是子類的原型指向父類的原型。
上面代碼中，子類是整體繼承父類。有時，只需要單個方法的繼承，這時可以采用下面的寫法。
ClassB.prototype.print = function() { ClassA.prototype.print.call(this); // some code}上面代碼中，子類B的print方法先調(diào)用父類A的print方法，再部署自己的代碼。這就等于繼承了父類A的print方法。
__proto__屬性
__proto__屬性指向當(dāng)前對象的原型對象，即構(gòu)造函數(shù)的prototype屬性。
var obj = new Object();obj.__proto__ === Object.prototype// trueobj.__proto__ === obj.constructor.prototype// true
上面代碼首先新建了一個對象obj，它的__proto__屬性，指向構(gòu)造函數(shù)（Object或obj.constructor）的prototype屬性。所以，兩者比較以后，返回true。
因此，獲取實例對象obj的原型對象，有三種方法。
上面三種方法之中，前兩種都不是很可靠。最新的ES6標(biāo)準(zhǔn)規(guī)定，__proto__屬性只有瀏覽器才需要部署，其他環(huán)境可以不部署。而obj.constructor.prototype在手動改變原型對象時，可能會失效。
var P = function () {};var p = new P();var C = function () {};C.prototype = p;var c = new C();c.constructor.prototype === p // false上面代碼中，C構(gòu)造函數(shù)的原型對象被改成了p，結(jié)果c.constructor.prototype就失真了。所以，在改變原型對象時，一般要同時設(shè)置constructor屬性。
C.prototype = p;C.prototype.constructor = C;c.constructor.prototype === p // true
所以，推薦使用第三種Object.getPrototypeOf方法，獲取原型對象。該方法的用法如下。
var o = new Object();Object.getPrototypeOf(o) === Object.prototype// true
可以使用Object.getPrototypeOf方法，檢查瀏覽器是否支持__proto__屬性，老式瀏覽器不支持這個屬性。
Object.getPrototypeOf({ __proto__: null }) === null上面代碼將一個對象的__proto__屬性設(shè)為null，然后使用Object.getPrototypeOf方法獲取這個對象的原型，判斷是否等于null。如果當(dāng)前環(huán)境支持__proto__屬性，兩者的比較結(jié)果應(yīng)該是true。
有了__proto__屬性，就可以很方便得設(shè)置實例對象的原型了。假定有三個對象machine、vehicle和car，其中machine是vehicle的原型，vehicle又是car的原型，只要兩行代碼就可以設(shè)置。
vehicle.__proto__ = machine;car.__proto__ = vehicle;
下面是一個實例，通過__proto__屬性與constructor.prototype屬性兩種方法，分別讀取定義在原型對象上的屬性。
Array.prototype.p = 'abc';var a = new Array();a.__proto__.p // abca.constructor.prototype.p // abc
顯然，__proto__看上去更簡潔一些。
通過構(gòu)造函數(shù)生成實例對象時，實例對象的__proto__屬性自動指向構(gòu)造函數(shù)的prototype對象。
var f = function (){};var a = {};f.prototype = a;var o = new f();o.__proto__ === a// true屬性的繼承
屬性分成兩種。一種是對象自身的原生屬性，另一種是繼承自原型的繼承屬性。
對象的原生屬性
對象本身的所有屬性，可以用Object.getOwnPropertyNames方法獲得。
Object.getOwnPropertyNames(Date)// ["parse", "arguments", "UTC", "caller", "name", "prototype", "now", "length"]
對象本身的屬性之中，有的是可以枚舉的（enumerable），有的是不可以枚舉的。只獲取那些可以枚舉的屬性，使用Object.keys方法。
Object.keys(Date) // []hasOwnProperty()
hasOwnProperty方法返回一個布爾值，用于判斷某個屬性定義在對象自身，還是定義在原型鏈上。
Date.hasOwnProperty('length')// trueDate.hasOwnProperty('toString')// falsehasOwnProperty方法是JavaScript之中唯一一個處理對象屬性時，不會遍歷原型鏈的方法。
對象的繼承屬性
用Object.create方法創(chuàng)造的對象，會繼承所有原型對象的屬性。
var proto = { p1: 123 };var o = Object.create(proto);o.p1 // 123o.hasOwnProperty("p1") // false獲取所有屬性
判斷一個對象是否具有某個屬性（不管是自身的還是繼承的），使用in運算符。
"length" in Date // true"toString" in Date // true
獲得對象的所有可枚舉屬性（不管是自身的還是繼承的），可以使用for-in循環(huán)。
var o1 = {p1: 123};var o2 = Object.create(o1,{ p2: { value: "abc", enumerable: true }});for (p in o2) {console.info(p);}// p2// p1為了在for...in循環(huán)中獲得對象自身的屬性，可以采用hasOwnProperty方法判斷一下。
for ( var name in object ) { if ( object.hasOwnProperty(name) ) { /* loop code */ }}獲得對象的所有屬性（不管是自身的還是繼承的，以及是否可枚舉），可以使用下面的函數(shù)。
function inheritedPropertyNames(obj) { var props = {}; while(obj) { Object.getOwnPropertyNames(obj).forEach(function(p) { props[p] = true; }); obj = Object.getPrototypeOf(obj); } return Object.getOwnPropertyNames(props);}用法如下：
inheritedPropertyNames(Date)// ["caller", "constructor", "toString", "UTC", "call", "parse", "prototype", "__defineSetter__", "__lookupSetter__", "length", "arguments", "bind", "__lookupGetter__", "isPrototypeOf", "toLocaleString", "propertyIsEnumerable", "valueOf", "apply", "__defineGetter__", "name", "now", "hasOwnProperty"]
對象的拷貝
如果要拷貝一個對象，需要做到下面兩件事情。
確保拷貝后的對象，與原對象具有同樣的prototype原型對象。
確保拷貝后的對象，與原對象具有同樣的屬性。
下面就是根據(jù)上面兩點，編寫的對象拷貝的函數(shù)。
function copyObject(orig) { var copy = Object.create(Object.getPrototypeOf(orig)); copyOwnPropertiesFrom(copy, orig); return copy;}function copyOwnPropertiesFrom(target, source) { Object .getOwnPropertyNames(source) .forEach(function(propKey) { var desc = Object.getOwnPropertyDescriptor(source, propKey); Object.defineProperty(target, propKey, desc); }); return target;}多重繼承
JavaScript不提供多重繼承功能，即不允許一個對象同時繼承多個對象。但是，可以通過變通方法，實現(xiàn)這個功能。
function M1(prop) { this.hello = prop;}function M2(prop) { this.world = prop;}function S(p1, p2) { this.base1 = M1; this.base1(p1); this.base2 = M2; this.base2(p2);}S.prototype = new M1();var s = new S(111, 222);s.hello // 111s.world // 222上面代碼中，子類S同時繼承了父類M1和M2。當(dāng)然，從繼承鏈來看，S只有一個父類M1，但是由于在S的實例上，同時執(zhí)行M1和M2的構(gòu)造函數(shù)，所以它同時繼承了這兩個類的方法。
新聞熱點
疑難解答
