JavaScript原型是对象的底层属性查找机制，通过[[Prototype]]隐式链向上查找；函数的prototype属性用于设置实例的原型，class和extends本质仍是基于原型链。

JavaScript 原型（prototype）到底是什么

原型不是某种“设计模式”或“语法糖”，而是 JavaScript 中对象的底层属性查找机制：每个对象内部都有一个隐式引用（[[Prototype]]），指向它的原型对象；当访问一个属性或方法时，如果当前对象没有该属性，引擎会沿着这个隐式链向上查找，直到找到或到达 null。

你写的 obj.toString() 能工作，不是因为 obj 自己定义了 toString，而是它继承自 Object.prototype —— 这就是原型链在起作用。

如何用 prototype 属性给构造函数添加共享方法

只有函数对象才有 prototype 属性（注意：这不是实例的 [[Prototype]]，而是用于初始化新实例的原型对象）。给它添加方法，所有通过 new 创建的实例都能共享使用，避免重复创建函数。

function Person(name) {
  this.name = name;
}
Person.prototype.sayHello = function() {
  return `Hello, I'm ${this.name}`;
};

const a = new Person('Alice');
const b = new Person('Bob');
console.log(a.sayHello === b.sayHello); // true —— 同一个函数引用

• Person.prototype 是将来每个 new Person() 实例的 [[Prototype]]
• 直接修改 Person.prototype = {...} 会切断已存在实例的原型链，慎用
• ES6 的 class 本质仍是基于原型，class A { m() {} } 等价于在 A.prototype.m 上定义方法

实现继承：为什么不能只靠 Child.prototype = Parent.prototype

这种写法会让子类和父类共用同一个原型对象，修改 Child.prototype.xxx 就等于改了 Parent.prototype.xxx，彻底破坏封装。正确做法是让 Child.prototype 继承 Parent.prototype，同时保持独立可扩展。

标准安全写法（ES5 兼容）：

function Parent(val) {
  this.val = val;
}
Parent.prototype.getVal = function() { return this.val; };

function Child(val, extra) {
  Parent.call(this, val); // 借用父构造函数初始化实例属性
  this.extra = extra;
}

// 关键：新建一个对象，其 [[Prototype]] 指向 Parent.prototype
Child.prototype = Object.create(Parent.prototype);
Child.prototype.constructor = Child; // 修复 constructor 指针

Child.prototype.getExtra = function() { return this.extra; };

• Object.create(Parent.prototype) 创建空对象，并将其 [[Prototype]] 设为 Parent.prototype
• 必须手动恢复 Child.prototype.constructor，否则它会指向 Parent
• 不调用 Parent.call(this, ...)，子类实例就不会拥有父类定义的实例属性（如 this.val）

现代写法：用 class 和 extends 但别忽略底层逻辑

class 只是语法糖，它背后依然依赖原型链。如果你没理解 [[Prototype]] 和 prototype 的区别，遇到问题（比如 instanceof 失败、方法丢失）时会完全无从下手。

class Animal {
  constructor(name) {
    this.name = name;
  }
  speak() {
    return `${this.name} makes a noise.`;
  }
}

class Dog extends Animal {
  constructor(name, breed) {
    super(name); // 必须调用，否则报错 ReferenceError
    this.breed = breed;
  }
  bark() {
    return `${this.name} barks!`;
  }
}

const d = new Dog('Rex', 'Golden');
console.log(d instanceof Dog);     // true
console.log(d instanceof Animal); // true —— 因为 Dog.prototype.[[Prototype]] === Animal.prototype

真正容易被忽略的是：子类的 constructor 默认没有 prototype 属性可写，且 super() 必须在访问 this 前调用 —— 这些限制都源于原型链初始化时机与 [[Construct]] 内部流程，不是语法随意定的规则。