TypeScript类组合的正确实现方式？基于MPJ组合优于继承视频

嘿，这个问题我之前折腾过好一阵子！在TypeScript里用类来实现「组合优于继承」，确实得顺着TS静态类型系统的脾气来，不然很容易碰到像你说的TS2339这类“属性不存在”的类型错误。

先给你拆解下问题根源：你用lodash的方法把其他类的方法挂到MurderRobotDog实例上，这是运行时动态添加成员，但TS是静态类型检查，编译阶段根本不知道这些后续添加的bark、kill方法，自然会报错。要解决这个问题，我们得让TS明确知道组合后的类拥有哪些能力，下面给你两种靠谱的实现方式：

方案一：显式委托（最直观、易维护） #

这是最符合TS类型系统的组合方式——通过在组合类内部持有其他能力类的实例，显式声明对应的方法并内部转发调用。

先定义基础的能力类：

class Dog {
  bark(): void {
    console.log("汪！汪！");
  }
}

class MurderRobot {
  kill(): void {
    console.log("目标已清除！");
  }
}

然后创建组合类MurderRobotDog，内部委托这两个类的能力：

class MurderRobotDog {
  private dogCapability: Dog;
  private robotCapability: MurderRobot;

  constructor() {
    this.dogCapability = new Dog();
    this.robotCapability = new MurderRobot();
  }

  // 显式声明bark方法，内部委托给Dog实例
  bark(): void {
    this.dogCapability.bark();
  }

  // 显式声明kill方法，内部委托给MurderRobot实例
  kill(): void {
    this.robotCapability.kill();
  }

  // 还可以自定义组合后的专属方法
  barkAndKill(): void {
    this.bark();
    this.kill();
  }
}

这样TS能完美识别MurderRobotDog的所有方法，不会再报类型错误，而且每个能力的来源都很清晰，后续维护也方便。

方案二：Mixin混入（灵活组合多能力） #

如果需要更灵活地组合多个能力（比如动态切换或叠加不同能力），可以用TS支持的Mixin模式，它能把多个类的能力“混入”到一个类中。

先定义Mixin的工具类型和混入函数：

// 定义一个基础构造函数类型，用于接收被混入的类
type Constructor<T = {}> = new (...args: any[]) => T;

// 混入Dog能力的函数
function WithDog<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    bark(): void {
      console.log("汪！汪！");
    }
  };
}

// 混入MurderRobot能力的函数
function WithMurderRobot<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    kill(): void {
      console.log("目标已清除！");
    }
  };
}

然后组合出我们的MurderRobotDog：

// 先定义一个基础空类（也可以是已有业务类）
class BaseRobotDog {}

// 叠加两个Mixin，得到最终的组合类
class MurderRobotDog extends WithMurderRobot(WithDog(BaseRobotDog)) {}

// 使用示例
const mrDog = new MurderRobotDog();
mrDog.bark(); // 正常调用，TS能识别
mrDog.kill(); // 正常调用，TS能识别

这种方式的优势是可以自由组合多个Mixin，比如后续想加个WithFly能力，直接叠加进去就行，扩展性很强。

为什么之前用lodash会报错？ #

用lodash的assign/merge是在运行时动态给实例加方法，但TS的静态类型系统无法感知这些运行时变化，所以编译阶段会认为MurderRobotDog没有bark、kill属性。如果非要用这种方式，你得手动做类型断言，但这并不推荐——因为它绕过了TS的类型检查，容易引入运行时错误：

// 不推荐的写法，仅作示例
const mrDog = new MurderRobotDog();
_.assign(mrDog, new Dog(), new MurderRobot());

// 手动类型断言才能调用
(mrDog as unknown as Dog & MurderRobot).bark();

总的来说，在TypeScript里实现类组合，优先选择显式委托或Mixin混入，既能贴合“组合优于继承”的设计思想，又能让TS的类型系统发挥作用，避免不必要的类型错误。

内容的提问来源于stack exchange，提问作者Glenn Mohammad