类继承 - 添加参数而不重写父构造函数参数

Question

我想延长以下课程：

class Person {
    constructor(name, age) {
        this._name = name;
        this._age = age;
    }
  
    get name() {
        return this._name;
    }
  
    get age() {
        return this._age;
    }
}

...通过添加

sport

及其吸气剂：

class Athlete extends Person {
    constructor(name, age, sport) {
        super();
        this._name = name;
        this._age = age;
        this._sport = sport;
    }
  
    get sport() {
        return this._sport;
    }
}

虽然上述方法有效，但我想避免重复基父构造函数的参数。以下方法行不通：

class Athlete extends Person {
    constructor(sport) {
        super();
        this._sport = sport;
    }
  
    get sport() {
        return this._sport;
    }
}

let athlete = new Athlete('Peter', 29, 'cricket');
console.log(athlete.name, athlete.age, athlete.sport); // name and age are not inherited, is returned 'undefined'

那么，如何在不重写基类字段的情况下向子类添加字段呢？

Answer 1

您需要传递参数，但您可以通过将它们传递给

super()

:

来避免分配所有参数

class Athlete extends Person {
    constructor(name, age, sport) {
        super(name, age); // pass arguments to super()
        this._sport = sport;
    }
  
    get sport() {
        return this._sport;
    }
}

let athlete = new Athlete('Peter', 29, 'cricket');
console.log(athlete.name, athlete.age, athlete.sport);

Answer 2

你想要的可以实现（使用解构参数（

...args

）语法来表示任意数量的参数），但是，不建议这样做（至少我是这样做的），并且它需要一定的成本，其中一些是可读性、易于调试、不易出错的代码等等（因为这使得代码更加晦涩，使得参数的顺序不那么清晰，并且可能传递错误数量的参数）：

class Person {
    constructor(name, age) {
        this._name = name;
        this._age = age;
    }
  
    get name() {
        return this._name;
    }
  
    get age() {
        return this._age;
    }
}

class Athlete extends Person {
    constructor(...args) {
        let sport = args.splice(-1)[0];
        super(...args);
        this._sport = sport;
    }
    
    get sport() {
        return this._sport;
    }
}

let athlete = new Athlete('Peter', 29, 'cricket');
console.log(athlete.name, athlete.age, athlete.sport);

可以使用

arguments

对象类似地实现：

class Person {
    constructor(name, age) {
        this._name = name;
        this._age = age;
    }
  
    get name() {
        return this._name;
    }
  
    get age() {
        return this._age;
    }
}

class Athlete extends Person {
    constructor() {
        let args = Array.from(arguments);
        let sport = args.splice(-1)[0];
        super(...args);
        this._sport = sport;
    }
    
    get sport() {
        return this._sport;
    }
}

let athlete = new Athlete('Peter', 29, 'cricket');
console.log(athlete.name, athlete.age, athlete.sport);

Answer 3

另一种方法是在其余...运算符之前

添加新参数：

class Person {
    constructor(name, age) {
        this._name = name;
        this._age = age;
    }
  
    get name() {
        return this._name;
    }
  
    get age() {
        return this._age;
    }
}

class Athlete extends Person {
    constructor(sport, ...args) {
        super(...args);
        this._sport = sport;
    }
    
    get sport() {
        return this._sport;
    }
}

let athlete = new Athlete('cricket', 'Peter', 29);
console.log(athlete.name, athlete.age, athlete.sport);

这提高了性能，但不一定提高可读性，这将奇怪的情况从构造函数不常用的函数的使用转变为随机顺序。

顺便说一句，我会推荐这里列出的任何解决方案，包括这个吗？绝对

不是。