前言

原型（Prototype）和原型链是 JS 中非常重要的一个概念。

原型和原型链机制允许我们在 JavaScript 中通过构造函数的原型，实现方法的共享，从而节省内存并提高代码的效率。

__proto__

在 JS 中，每个对象都有一个 __proto__ 属性，该属性就指向该对象的原型（prototype）。以下是一些输出结果，可以很直观的验证该结论。

const num = 1
console.dir(num.__proto__) // Number
console.log(num.__proto__ === Number.prototype) // true

const str = "1"
console.dir(str.__proto__) // String
console.log(str.__proto__ === String.prototype) // true

const bool = true
console.dir(bool.__proto__) // Boolean
console.log(bool.__proto__ === Boolean.prototype) // true

// ...

const arr = []
console.dir(arr.__proto__) // Array
console.log(arr.__proto__ === Array.prototype) // true

const obj = {}
console.dir(obj.__proto__) // Object
console.log(obj.__proto__ === Object.prototype) // true

需要注意的是，__proto__ 属性是内部属性，在实际开发中，推荐使用 Object.getPrototypeOf() 和 Object.setPrototypeOf() 方法来访问和设置对象的原型。

prototype

在上个代码段中我们使用到了 Number、String 等对象（访问了它们的 prototype 属性），因为他们其实都是 JS 内置函数对象，只有函数对象才拥有 prototype 属性，我们可以通过 prototype.constructor 查看创建它的构造函数。

以普通函数为例（普通函数也可以是构造函数，二者并无本质区别）：

function func() {}
// prototype.constructor 记录了创建它的构造函数
console.log(func.prototype.constructor === func) // true
// __proto__ 属性指向它的原型
console.log(func.__proto__ === Function.prototype) // true

显式的声明一个构造函数：

function Car(make, model, year) {
  this.make = make
  this.model = model
  this.year = year
}

Car.prototype.introduce = function () {
  console.log(`I'm the ${this.model}. I'm from ${this.make}. I was made in ${this.year}.`)
}

const beetle = new Car("Volkswagen", "Beetle", 1938)
// prototype.constructor 记录了创建它的构造函数
console.log(Car.prototype.constructor === Car) // true
// __proto__ 属性指向它的原型
console.log(beetle.__proto__ === Car.prototype) // true
// 调用原型上的方法
beetle.introduce() // I'm the Beetle. I'm from Volkswagen. I was made in 1938.

这段代码很明显的说明了：

• 在 JS 中，每个对象都有一个 __proto__ 属性，指向该对象的原型（prototype）。

• 函数对象拥有 prototype 属性，prototype.constructor 记录了创建它的构造函数。

原型链

在上面的代码中还表现了原型链的特征。

beetle 本身没有 introduce 方法，却能够调用 introduce 方法，是因为 introduce 方法被添加到了 Car 构造函数的原型上。

Car.prototype.introduce = function () {
  console.log(`I'm the ${this.model}. I'm from ${this.make}. I was made in ${this.year}.`)
}

当调用 beetle.introduce() 时，JavaScript 引擎会首先在 beetle 对象本身上查找 introduce 方法，在 beetle 上找不到该方法，它会继续在 beetle 对象的原型链上查找 Car 构造函数的原型，并最终找到 introduce 方法。

因此，当调用 beetle.introduce() 时，实际上是在 beetle 对象的原型链上找到了 introduce 方法，从而成功调用了该方法。

一张图表示这段代码的原型链：

总结

在 JS 中，每个对象都有一个原型，该原型指向创建该对象的构造函数的 prototype 属性，prototype 本身也是一个对象。

原型链是一个个对象的原型的组合，当访问一个对象的属性或方法时，JS 会在对象自身查找，如果该对象没有这个属性或方法，JavaScript 就会尝试从对象的原型中查找，如果原型中也没有，就会在原型的原型中查找，直接找到或到达原型链的顶端（通常是 Object 的原型），这个查找的过程就组成了原型链。