原型链

原型链就是一系列对象的链接。通常来说，这个链接的作用是：如果在对象上没有找到需要的属性或者方法引用，引擎就会继续在[[Prototype]]关联的对象上进行查找。同理，如果在后者中也没有找到需要的引用，就会继续查找它的[[Prototype]]，以此类推。（[[Prototype]]机制就是存在于对象中的一个内部链接，它会引用其它对象） ——参考《你不知道的JavaScript》上卷

本质 - 对象间的关联关系

图/原型链示例

function Car() {};
let car1 = new Car();
let car2 = new Car();
let o1 = {};

// 原型链的查找终点
Object.prototype.__proto__ === null

// Object 的 [[Prototype]] 指向 Function.prototype，因此 typeof Object 的输出结果为 'function'
Object.__proto__ === Function.prototype
typeof Object // ’function‘

// Function 的 prototype 和 [[Prototype]] 都指向 Function 的原型
Function.prototype === Function.__proto__

// 函数的原型的 [[Prototype]] 指向 Object 的原型
Function.prototype.__proto__ === Object.prototype
Car.prototype.__proto__ === Object.prototype

// new 出来的实例的 [[Prototype]] 指向其构造函数的原型
car1.__proto__ === Car.prototype
car2.__proto__ === Car.prototype
car1.__proto__ === car2.__proto__

// 对象的 [[Prototype]] 指向 Object 的原型
o1.__proto__ === Object.prototype

instanceof 和 isPrototypeOf

• instanceof 操作符用于测试构造函数的原型是否出现在一个对象的原型链中，注意：语法是 object instanceof constructor

let o1 = {};
o1 instanceof Object // true, 因为 o1.__proto__ === Object.prototype

let a = {};
let b = Object.create{a};
b instanceof a // Uncaught TypeError: Right-hand side of 'instanceof' is not callable，因为a不是构造函数

Object instanceof Function // true, 因为 Object.__proto__ === Function.prototype
Object instanceof Object // true, 因为 Object.__proto__.__proto__ === Object.prototype

• isPrototypeOf() 方法用于测试一个对象是否存在于另一个对象的原型链上

let a = {};
let b = Object.create{a};

Object.isPrototypeOf(a); // false, 因为 Object 不在对象 a 的原型链上
Object.prototype.isPrototypeOf(a); // true，因为 Object.prototype 在对象 a 的原型链上

a.isPrototypeOf(b); // true, 因为 b.__proto__ === a

__proto__的大致实现

__proto__ 存在于 Object.prototype 中，__proto__看起来很像一个属性，但是实际上它更像一个 getter/setter。

// __proto__的实现大致上是这样的
Object.defineProperty(Object.prototype, "__proto__", {
	get: function() {
        return Object.getPrototypeOf(this);
    },
    set: function(o) {
        Object.setPrototypeOf(this, o);
		return o;
    }
});

委托

带new的函数调用通常被称为“构造函数调用”，尽管实际上它们和传统面向类语言中的类构造函数不一样。虽然 JavaScript 中的机制和传统面向类语言中的“类初始化”和“类集成”很相似，但是 JavaScript 中的机制有一个核心区别，那就是不会复制，对象之间是通过内部的 [[Prototype]] 链关联的。

出于各种原因， 以“继承” 结尾的术语（包括“原型继承”） 和其他面向对象的术语都无法帮助你理解 JavaScript 的真实机制（不仅仅是限制我们的思维模式）。相比之下， “委托” 是一个更合适的术语， 因为对象之间的关系不是复制而是委托。

委托行为意味着某些对象在找不到属性或者方法引用时会把这个请求委托给另一个对象。
仅仅是限制我们的思维模式`）。相比之下， “委托” 是一个更合适的术语， 因为对象之间的关系不是复制而是委托。

委托行为意味着某些对象在找不到属性或者方法引用时会把这个请求委托给另一个对象。