javascript 中实现继承机制的性能优化，核心在于避免在构造函数内部重复定义方法，转而使用原型链共享函数引用。具体做法是将公共方法挂载到构造函数的 prototype 对象上，这样所有实例都指向同一块内存地址，既节省内存又提升初始化速度。同时，推荐使用 es6 的 class 语法糖或寄生组合式继承来简化代码结构，确保属性与方法的正确分离。
为什么要在原型上定义方法而不是构造函数内？
在构造函数内部直接定义方法会导致每个实例都创建一个新的函数对象，造成严重的内存浪费。将方法放在原型上，可以让所有实例共享同一个函数引用，这是最基础且有效的性能优化手段。
function Animal(name) {
this.name = name;
}
// 优化：方法定义在原型上
Animal.prototype.speak = function() {
console.log(this.name + ' makes a noise.');
};
const dog = new Animal('Dog');
const cat = new Animal('Cat');
console.log(dog.speak === cat.speak); // true, 共享同一引用
上述代码中，dog.speak 和 cat.speak 指向同一个函数地址。如果定义在构造函数内，每次 new 操作都会生成新的函数副本，导致内存占用线性增长。通过原型共享，无论创建多少个实例，内存中只存在一份方法代码。
立即学习“Java免费学习笔记（深入）”；
如何安全地建立原型链而不丢失 constructor？
传统的原型链继承方式（如 Child.prototype = new Parent()）会执行父类构造函数，可能导致不必要的副作用，且子类的 constructor 属性会指向父类。使用 Object.create() 可以创建一个干净的原型对象，保持原型链清晰且不影响构造函数本身。
function Parent(name) {
this.name = name || 'Parent';
}
function Child(name, age) {
Parent.call(this, name); // 借用构造函数传递参数
this.age = age;
}
// 优化：使用 Object.create 建立原型链
Child.prototype = Object.create(Parent.prototype);
Child.prototype.constructor = Child; // 修复 constructor 指向
Child.prototype.sayAge = function() {
console.log(this.age);
};
const child = new Child('Child', 5);
console.log(child instanceof Parent); // true
console.log(child instanceof Child); // true
console.log(child.constructor === Child); // true
这种寄生组合式继承模式避免了父类构造函数的重复执行，同时通过手动修正 constructor 保持了实例的类型识别准确性。相比直接赋值原型对象，这种方式更加安全和灵活，是现代 JavaScript 库中常用的继承实现基础。
ES6 Class 语法下的继承性能表现如何？
ES6 的 class 关键字本质上是基于原型的语法糖，其底层实现与寄生组合式继承一致。使用 extends 和 super() 可以更直观地表达继承关系，且在 V8 等现代引擎中经过高度优化，性能开销极小。但需注意，class 中的方法默认定义在原型上，而字段（Field）定义在实例上，这种区分有助于理解内存分布。
class Parent {
constructor(name) {
this.name = name;
}
speak() {
console.log(this.name + ' speaks');
}
}
class Child extends Parent {
constructor(name, age) {
super(name); // 调用父类构造函数
this.age = age;
}
sayAge() {
console.log(this.age);
}
}
const c = new Child('Child', 5);
c.speak(); // Child speaks
c.sayAge(); // 5
在实际开发中，优先使用 ES6 class 语法，因为它可读性更强且不易出错。对于需要兼容旧环境的项目，可以使用 Babel 等工具将其转译为寄生组合式继承代码。关键在于理解无论是哪种写法，核心优化点始终是将方法置于原型链上，而非实例内部。
