TypeScript：类组合

Question

根据 MPJ 的这个精彩的 Composition over Inheritance 视频，我一直在尝试用 TypeScript 制定组合。我想编写类，而不是对象或工厂函数。这是我到目前为止的努力（在 lodash 的帮助下）：

class Barker {
  constructor(private state) {}

  bark() {
    console.log(`Woof, I am ${this.state.name}`);
  }
}

class Driver {
  constructor(private state) {}

  drive() {
    this.state.position = this.state.position + this.state.speed;
  }
}

class Killer {
  constructor(private state) {}

  kill() {
    console.log(`Burn the ${this.state.prey}`);
  }
}

class MurderRobotDog {
  constructor(private state) {
    return _.assignIn(
      {},
      new Killer(state),
      new Driver(state),
      new Barker(state)
    );
  }
}

const metalhead = new MurderRobotDog({ 
  name: 'Metalhead', 
  position: 0, 
  speed: 100, 
  prey: 'witch' 
});

metalhead.bark(); // expected: "Woof, I am Metalhead"
metalhead.kill(); // expected: "Burn the witch"

这导致：

TS2339：“MurderRobotDog”类型上不存在属性“bark”

TS2339：“MurderRobotDog”类型上不存在属性“kill”

在 TypeScript 中进行类组合的正确方法是什么？

Answer 1

组合与继承

我认为我们应该区分组合和继承，并重新考虑我们想要实现的目标。正如评论者所指出的，MPJ 所做的实际上是使用 mixins 的一个示例。这基本上是一种继承形式，在目标对象上添加实现（混合）。

多重继承

我试图想出一个巧妙的方法来做到这一点，这是我最好的建议：

type Constructor<I extends Base> = new (...args: any[]) => I;

class Base {}

function Flies<T extends Constructor<Base>>(constructor: T = Base as any) {
  return class extends constructor implements IFlies {
    public fly() {
      console.log("Hi, I fly!");
    }
  };
}

function Quacks<T extends Constructor<Base>>(constructor: T = Base as any) {
  return class extends constructor implements ICanQuack {
    public quack(this: IHasSound, loud: boolean) {
      console.log(loud ? this.sound.toUpperCase() : this.sound);
    }
  };
}

interface IHasSound {
  sound: string;
}

interface ICanQuack {
  quack(loud: boolean): void;
}

interface IQuacks extends IHasSound, ICanQuack {}

interface IFlies {
  fly(): void;
}

class MonsterDuck extends Quacks(Flies()) implements IQuacks, IFlies {
  public sound = "quackly!!!";
}

class RubberDuck extends Quacks() implements IQuacks {
  public sound = "quack";
}

const monsterDuck = new MonsterDuck();
monsterDuck.quack(true); // "QUACKLY!!!"
monsterDuck.fly(); // "Hi, I fly!"

const rubberDuck = new RubberDuck();
rubberDuck.quack(false); // "quack"

使用这种方法的好处是您可以在继承方法的实现中允许访问所有者对象的某些属性。虽然可以使用更好的命名，但我认为这是一个非常有潜力的解决方案。

作曲

组合不是将函数混合到对象中，而是设置应该包含在其中的行为，然后将这些行为作为对象内部的自包含库来实现。

interface IQuackBehaviour {
  quack(): void;
}

interface IFlyBehaviour {
  fly(): void;
}

class NormalQuack implements IQuackBehaviour {
  public quack() {
    console.log("quack");
  }
}

class MonsterQuack implements IQuackBehaviour {
  public quack() {
    console.log("QUACK!!!");
  }
}

class FlyWithWings implements IFlyBehaviour {
  public fly() {
    console.log("I am flying with wings");
  }
}

class CannotFly implements IFlyBehaviour {
  public fly() {
    console.log("Sorry! Cannot fly");
  }
}

interface IDuck {
  flyBehaviour: IFlyBehaviour;
  quackBehaviour: IQuackBehaviour;
}

class MonsterDuck implements IDuck {
  constructor(
    public flyBehaviour = new FlyWithWings(),
    public quackBehaviour = new MonsterQuack()
  ) {}
}

class RubberDuck implements IDuck {
  constructor(
    public flyBehaviour = new CannotFly(),
    public quackBehaviour = new NormalQuack()
  ) {}
}

const monsterDuck = new MonsterDuck();
monsterDuck.quackBehaviour.quack(); // "QUACK!!!"
monsterDuck.flyBehaviour.fly(); // "I am flying with wings"

const rubberDuck = new RubberDuck();
rubberDuck.quackBehaviour.quack(); // "quack"

如您所见，实际区别在于复合材料不知道使用它的对象上存在的任何属性。这可能是件好事，因为它符合组合优于继承的原则。

Answer 2

不幸的是，没有简单的方法可以做到这一点。目前有一个提议允许extends 关键字允许你这样做，但它仍在this GitHub issue 中讨论。

您唯一的其他选择是使用 TypeScript 中可用的Mixins functionality，但这种方法的问题是您必须重新定义要从“继承”类中重用的每个函数或方法。