js类class继承实现_js类class继承全面讲解

javascript中的类继承本质是子类复用父类属性和方法并扩展自身特性，主要通过原型链实现，例如将子类原型指向父类实例，并借助构造函数继承实例属性；es6引入class和extends语法糖简化了继承逻辑，使用super调用父类构造函数和方法；避免原型链污染需不修改内置对象原型、使用object.create(null)创建无原型对象或map/weakmap存储数据、验证用户输入等；super关键字用于调用父类构造函数和访问父类方法；多重继承可通过混入（合并多个类的属性和方法）或组合（通过对象组合功能模块）模拟实现。

JavaScript中的类继承，本质上就是让子类能够复用父类的属性和方法，同时还能扩展自己的特性。实现方式有很多种，各有优劣，没有绝对完美的方案，选择哪种取决于具体的应用场景和个人偏好。

解决方案

最常见的实现方式是基于原型链。简单来说，就是将子类的原型指向父类的实例。这样，子类就可以通过原型链访问到父类的属性和方法。

function Parent(name) {
this.name = name;
}
Parent.prototype.sayHello = function() {
console.log("Hello, I'm " + this.name);
};
function Child(name, age) {
Parent.call(this, name); // 借用构造函数，继承父类的实例属性
this.age = age;
}
// 核心：将子类的原型指向父类的实例
Child.prototype = Object.create(Parent.prototype);
Child.prototype.constructor = Child; // 修正 constructor 指向
Child.prototype.sayAge = function() {
console.log("I'm " + this.age + " years old.");
};
const child = new Child("Alice", 10);
child.sayHello(); // 输出: Hello, I'm Alice
child.sayAge();   // 输出: I'm 10 years old.

这种方式的优点是简单易懂，兼容性好。缺点是子类实例共享父类实例的属性，如果父类实例属性是引用类型，可能会出现问题。另外，每次创建子类实例，都要调用 Parent.call(this, name)，略显繁琐。

ES6 引入了 class 和 extends 关键字，提供了更简洁的语法糖，但本质上仍然是基于原型链的。

class Parent {
constructor(name) {
this.name = name;
}
sayHello() {
console.log("Hello, I'm " + this.name);
}
}
class Child extends Parent {
constructor(name, age) {
super(name); // 调用父类的构造函数
this.age = age;
}
sayAge() {
console.log("I'm " + this.age + " years old.");
}
}
const child = new Child("Bob", 12);
child.sayHello(); // 输出: Hello, I'm Bob
child.sayAge();   // 输出: I'm 12 years old.

使用 class 和 extends 可以使代码更易读，更易维护。super() 关键字用于调用父类的构造函数和方法，避免了手动调用 Parent.call(this, name)。

还有一些其他的继承方式，例如组合继承、寄生式继承、寄生组合式继承等，但实际应用中，基于原型链的继承和 ES6 的 class 继承是最常用的。选择哪种方式，取决于具体的项目需求和团队规范。 个人更倾向于使用 ES6 的 class 继承，代码更简洁，也更符合现代 JavaScript 的编程风格。

如何避免原型链污染？

原型链污染是一个安全问题，攻击者可以通过修改对象的原型来影响所有基于该原型创建的对象。在继承的场景下，尤其需要注意这个问题。

避免原型链污染的关键在于：

1. 避免直接修改 Object.prototype 或其他内置对象的原型。 这是最重要的一点。永远不要为了方便而直接修改内置对象的原型，这会带来很大的安全风险。
2. 使用 Object.create(null) 创建对象。 这种方式创建的对象没有原型链，可以避免原型链污染。但需要注意的是，这种对象没有继承任何内置方法，例如 toString、hasOwnProperty 等。
3. 使用 Object.freeze() 或 Object.seal() 冻结对象。 Object.freeze() 可以冻结对象，使其属性不可修改。Object.seal() 可以封闭对象，使其不能添加新的属性，但可以修改已有的属性。
4. 使用 Map 或 WeakMap 代替普通对象。 Map 和 WeakMap 不会受到原型链污染的影响。
5. 对用户输入进行验证和过滤。 避免用户输入的数据直接用于修改对象的属性。

在继承的场景下，如果需要修改原型，尽量使用 Object.create() 创建一个新的原型对象，而不是直接修改父类的原型。同时，对子类添加的属性进行验证，避免恶意代码注入。

super 关键字在继承中的作用是什么？

super 关键字在 ES6 的 class 继承中扮演着重要的角色，它主要有两个作用：

1. 调用父类的构造函数。 在子类的构造函数中，必须先调用 super() 才能使用 this 关键字。super() 相当于调用 Parent.call(this, …args)，用于初始化父类的属性。如果没有调用 super()，会抛出一个 ReferenceError 错误。
2. 访问父类的方法。 可以使用 super.methodName() 调用父类的方法。这在子类需要重写父类方法，但又想保留父类原有功能时非常有用。

class Parent {
constructor(name) {
this.name = name;
}
sayHello() {
console.log("Hello, I'm " + this.name);
}
}
class Child extends Parent {
constructor(name, age) {
super(name); // 调用父类的构造函数
this.age = age;
}
sayHello() {
super.sayHello(); // 调用父类的 sayHello 方法
console.log("I'm also a child.");
}
}
const child = new Child("Charlie", 8);
child.sayHello();
// 输出:
// Hello, I'm Charlie
// I'm also a child.

super 关键字简化了继承的语法，使代码更易读，更易维护。它确保了父类的初始化逻辑能够正确执行，同时也提供了访问父类方法的便捷方式。

如何实现多重继承？

JavaScript 本身并不支持传统意义上的多重继承，即一个类同时继承多个父类的属性和方法。但可以通过一些技巧来模拟多重继承的效果。

1. 混入 (Mixins)。 混入是一种将多个类的属性和方法合并到一个类中的技术。可以通过遍历多个类的原型，将它们的属性和方法复制到目标类的原型上。

function mixin(target, ...sources) {
for (const source of sources) {
for (const key of Object.getOwnPropertyNames(source.prototype)) {
if (key !== 'constructor') {
Object.defineProperty(target.prototype, key, Object.getOwnPropertyDescriptor(source.prototype, key));
}
}
}
}
class CanFly {
fly() {
console.log("I can fly!");
}
}
class CanSwim {
swim() {
console.log("I can swim!");
}
}
class Duck {
constructor(name) {
this.name = name;
}
}
mixin(Duck, CanFly, CanSwim);
const duck = new Duck("Donald");
duck.fly();  // 输出: I can fly!
duck.swim(); // 输出: I can swim!

混入的优点是简单易用，可以灵活地组合多个类的功能。缺点是可能会出现命名冲突，需要仔细处理。

2. 组合 (Composition)。 组合是一种将多个对象组合在一起，形成一个新的对象的技术。每个对象负责一部分功能，通过组合将这些功能整合在一起。

class Flyable {
constructor(obj) {
this.obj = obj;
}
fly() {
console.log(this.obj.name + " can fly!");
}
}
class Swimmable {
constructor(obj) {
this.obj = obj;
}
swim() {
console.log(this.obj.name + " can swim!");
}
}
class Duck {
constructor(name) {
this.name = name;
this.flyable = new Flyable(this);
this.swimmable = new Swimmable(this);
}
fly() {
this.flyable.fly();
}
swim() {
this.swimmable.swim();
}
}
const duck = new Duck("Daisy");
duck.fly();  // 输出: Daisy can fly!
duck.swim(); // 输出: Daisy can swim!

组合的优点是避免了命名冲突，代码更清晰，更易维护。缺点是需要手动将各个对象组合在一起，略显繁琐。

选择哪种方式取决于具体的应用场景。如果需要灵活地组合多个类的功能，可以选择混入。如果需要避免命名冲突，代码更清晰，可以选择组合。个人更倾向于使用组合，因为它更符合面向对象的设计原则。