有没有在typescript中用mixin模拟super？

Question

我通过Mixins使用多重继承（使用替代模式）。有没有办法用这个模式得到类似于“超级”的东西？考虑这里的例子

abstract class Activatable{
    private activated: boolean = false;
    constructor(){}
    public activate(): void {
        this.activated = true;
        console.log('Activatable activated')
  }
}

class SomethingElse{};

interface ThingParent extends Activatable{}

class ThingParent extends SomethingElse{
    public activate(): void {
        (this as Activatable).activate();
        let addSomeValueHere = true;
        console.log('Thing parent activated')
    }
}

applyMixins(ThingParent, [Activatable]);

class Thing extends ThingParent {
    constructor(){
        super()
    }
    public activate(): void {
        super.activate();
        
        console.log('Thing activated');
    }
}

let thing = new Thing();
thing.activate();



function applyMixins(derivedCtor: any, constructors: any[]) {
  constructors.forEach((baseCtor) => {
    Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
      Object.defineProperty(
        derivedCtor.prototype,
        name,
        Object.getOwnPropertyDescriptor(baseCtor.prototype, name) ||
          Object.create(null)
      );
    });
  });
}

Thing扩展了ThingP，它通过混合扩展了一个名为Activable的类。当我在Thing上调用激活时，我也想在ThingP的和Activable上调用激活，但它只在Activable上调用。

如果我更改了ThingParent上函数的名称，我可以直接调用该函数，但ThingParents不能通过super访问Activatable（因为它扩展了SomethingElse）。那我就得叫这两个超级。activate（）和这个。thing的thingParentActivate（）。activate（），所以如果可能的话，我想避免这种模式。

有没有其他选择？

（链接到打字操场上的代码：https://www.typescriptlang.org/play?#code/IYIwzgLgTsDGEAJYBthjAggvAlgN2AlGQFMBvAWACgFaEAHKfQkhOCZiEgEwC4EQAe0GlgAOwQBeBADNgyMCQDc1OkkFjIUAK7xBUABQBKMgF9VdetpDIcsNrgJdj-PIJzcElGmroQAFjhgAHTsnDxSCNDayha6poiJMHIggDmBgDk2BxOxKxhTjyZRhbmVOXUKGgYAMqCALYkAThiaQCiCuSmKlTUrVxQcrCsACqBbQAKuFAkYogkAB5cYtwYOZz5ZtRVqOgI461p07PzCEsrawj1TS1tnYRealY2dg65LC4Ibh5ecb4GFoYNBYRyEFJGUJg5xGXrxWikRDAbjcG4kABq8hiAAkSLNItFYj54rANGAkil0llDm0GDM5kjocVSsSEOVKlRqvsaWlzss5lceScGX9TNNE9IYTP81GBtPQ8cZ-uVntZbPZCp8jK53J4nvD

Answer 1

正如你所知道的，JavaScript类不支持多重继承，所以如果你想得到那样的效果，你需要做一些事情来模拟它。Mixins是实现这一点的一种方式，但是它们并不真正支持有冲突的方法名。如果你有冲突的方法名，那么mixins将会破坏所有的方法名，只留下一个，这不是你想要的。

如果要在子类的实例上调用特定的超类的方法，可以直接使用Function.prototype.call（），该实例作为thisarg。而不是Activatable::activate（），您可以调用Activatable.prototype.activate.call（this）；。

让我们试一试：

interface ThingParent extends Activatable { }
class ThingParent extends SomethingElse {
    public activate(): void {
        Activatable.prototype.activate.call(this);
        let addSomeValueHere = true;
        console.log('Thing parent activated')
    }
}

class Thing extends ThingParent {
    constructor() {
        super()
    }
    public activate(): void {
        ThingParent.prototype.activate.call(this);
        console.log('Thing activated');
    }
}

let thing = new Thing();
thing.activate();
// [LOG]: "Activatable activated" 
// [LOG]: "Thing parent activated" 
// [LOG]: "Thing activated" 

这会编译好并产生您期望的输出。

在更复杂的场景中，您可能会决定需要混合使用直接方法调用或其他方法。

代码的游乐场链接