ES6 中从父类调用子方法

从父类调用子方法是好还是坏做法？

class Parent {
    constructor() {
        // if 'autoPlay' exists (was implemented) in chain
        if (this.autoPlay) {
            this.autoPlay(); // execute from parent
        }
    }
}

class ChildA extends Parent {
    autoPlay() {
        console.log('Child');
    }
}

class ChildB extends Parent {
    // 'autoPlay' wasn't implemented
}

const childA = new ChildA();
const childB = new ChildB();

从父类调用子方法是一个好习惯吗？

是的，这是一种完全正常的做法。父类只调用实例的某些方法，如果子类重写了该方法，则调用子方法。但是，您通常不会执行这样的“我的实例是否定义了此方法”测试，您只是调用它。如果默认情况下您不想执行任何操作，只需定义一个空方法（如 @scipper 的答案）。如果您想使方法抽象（强制子类重写它），您可以将其保留为未定义，或者定义一个抛出适当异常的方法。

从父方法调用子方法是一种不好的做法构造函数?

是的。不要那样做。（这是一个问题all语言）。

构造函数的目的是初始化实例，仅此而已。将副作用的调用留给调用者。这将确保所有子构造函数也将完成其初始化。

一个人为的例子：

class Parent {
    autoPlay() {
        this.play("automatically "); // call child method
    }
    play(x) {
        console.log(x+"playing default from "+this.constructor.name);
    }
}

class ChildA extends Parent {
    // does not override play
}
class ChildB extends Parent {
    constructor(song) {
        super();
        this.song = song;
    }
    play(x) {
        console.log(x+"playing "+this.song+" from ChildB");
    }
}

const child1 = new ChildA();
child1.autoPlay();
const child2 = new ChildB("'Yeah'");
child2.autoPlay();

请注意，如果Parent构造函数确实调用了autoplay。如果您不希望在实例化后到处都需要额外的方法调用，请使用辅助函数。它甚至可能是一个静态方法：

class Parent {
    autoPlay() { … }
    play { … }
    static createAndAutoPlay(...args) {
        const instance = new this(...args);
        instance.autoPlay();
        return instance;
    }
}
…
const child1 = ChildA.createAndAutoPlay();
const child2 = ChildB.createAndAutoPlay("'Yeah'");