JavaScript是一门基于原型的面向对象语言，本身没有传统面向对象语言中的类概念，继承的实现依赖原型链机制，ES6引入的class语法本质上是原型链继承的语法糖。理解JavaScript继承的实现方式，是掌握这门语言面向对象特性的关键。
原型链继承的实现原理
原型链是JavaScript实现继承的核心基础，每个对象都有一个隐式原型__proto__，指向其构造函数的原型对象prototype，当访问对象的属性时，会先在自身查找，找不到则沿着原型链向上查找，直到找到null为止。利用这个特性，我们可以让子类的原型指向父类的实例，从而实现继承。
基本实现代码
// 定义父类构造函数
function Parent(name) {
this.name = name;
this.hobbies = ['reading', 'coding'];
}
// 父类原型上添加方法
Parent.prototype.getName = function() {
return this.name;
};
// 定义子类构造函数
function Child(age) {
this.age = age;
}
// 核心：子类原型指向父类实例，实现原型链继承
Child.prototype = new Parent('parent');
// 修复子类原型的构造函数指向，否则constructor会指向Parent
Child.prototype.constructor = Child;
// 子类原型上添加自己的方法
Child.prototype.getAge = function() {
return this.age;
};
// 测试继承效果
const child1 = new Child(18);
console.log(child1.getName()); // 输出 parent
console.log(child1.getAge()); // 输出 18
console.log(child1 instanceof Parent); // 输出 true
console.log(child1 instanceof Child); // 输出 true
原型链继承的优缺点
优点是实现简单，能继承父类原型上的方法；缺点是存在两个明显问题：一是父类实例的引用类型属性会被所有子类实例共享，修改一个实例的引用类型属性会影响其他实例；二是创建子类实例时，无法向父类构造函数传参。
构造函数继承的实现方式
构造函数继承也叫经典继承，核心是在子类构造函数中调用父类构造函数，通过call或apply改变父类中this的指向，让父类的属性在子类实例上初始化，避免引用类型属性共享的问题。
实现代码示例
// 父类构造函数
function Parent(name) {
this.name = name;
this.hobbies = ['reading', 'coding'];
}
Parent.prototype.getName = function() {
return this.name;
};
// 子类构造函数
function Child(name, age) {
// 调用父类构造函数，将this指向当前子类实例
Parent.call(this, name);
this.age = age;
}
// 测试
const child1 = new Child('child1', 18);
const child2 = new Child('child2', 20);
child1.hobbies.push('swimming');
console.log(child1.hobbies); // 输出 ["reading", "coding", "swimming"]
console.log(child2.hobbies); // 输出 ["reading", "coding"]，引用类型属性不会共享
console.log(child1.getName); // 输出 undefined，无法继承父类原型上的方法
构造函数继承的优缺点
优点是解决了引用类型属性共享的问题，创建子类实例时可以向父类传参；缺点是无法继承父类原型上的方法，每个子类实例都会创建一份父类属性的副本，方法复用性低。
组合继承的实现方案
组合继承是将原型链继承和构造函数继承结合起来的方式，用构造函数继承父类实例属性，用原型链继承父类原型方法，是JavaScript中常用的继承方式之一。
实现代码示例
// 父类构造函数
function Parent(name) {
this.name = name;
this.hobbies = ['reading', 'coding'];
}
Parent.prototype.getName = function() {
return this.name;
};
// 子类构造函数
function Child(name, age) {
// 构造函数继承，继承实例属性
Parent.call(this, name);
this.age = age;
}
// 原型链继承，继承原型方法
Child.prototype = new Parent();
// 修复构造函数指向
Child.prototype.constructor = Child;
// 子类原型方法
Child.prototype.getAge = function() {
return this.age;
};
// 测试
const child1 = new Child('child1', 18);
const child2 = new Child('child2', 20);
child1.hobbies.push('swimming');
console.log(child1.hobbies); // 输出 ["reading", "coding", "swimming"]
console.log(child2.hobbies); // 输出 ["reading", "coding"]
console.log(child1.getName()); // 输出 child1，能调用父类原型方法
console.log(child2.getAge()); // 输出 20
组合继承的优缺点
优点是融合了两种继承方式的优点，既能继承实例属性避免共享，又能继承原型方法实现复用；缺点是父类构造函数会被调用两次，一次是在创建子类原型时，一次是在子类构造函数内部，存在不必要的性能消耗。
ES6 class继承的实现
ES6引入的class语法让JavaScript的继承写法更接近传统面向对象语言，其底层本质还是基于原型链，只是提供了更清晰的语法糖。
实现代码示例
// 定义父类
class Parent {
constructor(name) {
this.name = name;
this.hobbies = ['reading', 'coding'];
}
// 父类方法定义在原型上
getName() {
return this.name;
}
}
// 定义子类，通过extends关键字继承父类
class Child extends Parent {
constructor(name, age) {
// 调用super()执行父类构造函数，必须在this之前调用
super(name);
this.age = age;
}
getAge() {
return this.age;
}
}
// 测试
const child1 = new Child('child1', 18);
const child2 = new Child('child2', 20);
child1.hobbies.push('swimming');
console.log(child1.hobbies); // 输出 ["reading", "coding", "swimming"]
console.log(child2.hobbies); // 输出 ["reading", "coding"]
console.log(child1.getName()); // 输出 child1
console.log(child1.getAge()); // 输出 18
console.log(child1 instanceof Parent); // 输出 true
原型链继承与class继承的对比
| 对比维度 | 原型链继承 | class继承 |
|---|---|---|
| 语法复杂度 | 需要手动操作原型，修复constructor指向，语法较繁琐 | 通过extends和super关键字实现，语法简洁清晰 |
| 父类调用方式 | 需要手动创建父类实例赋值给子类原型 | 通过super()自动调用父类构造函数，必须在this前调用 |
| 静态方法继承 | 需要手动将父类静态属性赋值给子类 | 自动继承父类的静态方法和属性 |
| 底层实现 | 直接基于原型链操作 | 本质是原型链继承的语法糖，底层逻辑一致 |
在实际开发中，如果项目支持ES6语法，优先使用class继承，代码可读性和维护性更好；如果需要兼容低版本环境，可以选择组合继承等基于原型链的实现方案。
JavaScript继承原型链class继承原型对象构造函数修改时间：2026-07-06 18:36:31