根据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'
类型中不存在TS2339:财产'杀戮'在' MurderRobotDog'
类型中不存在
在TypeScript中进行类合成的正确方法是什么?
答案 0 :(得分:1)
不幸的是,没有简单的方法可以做到这一点。目前有一项建议允许extends
关键字允许您执行此操作,但仍在this GitHub issue中讨论。
您唯一的另一个选择是使用TypeScript中提供的Mixins functionality,但该方法的问题是您必须重新定义要从“继承”重用的每个函数或方法类。
答案 1 :(得分:0)
我认为我们应该在构成和继承之间做出区分,并重新考虑我们要实现的目标。正如评论员所指出的那样,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"
如您所见,实际的区别在于,复合材料不知道使用它的对象上存在的任何属性。这可能是一件好事,因为它符合“继承而不是继承”的原则。