TypeScript中如何将对象解析为类实例并区分Tree子类？

一、普通对象转类实例的问题 #

TypeScript中，字面量对象和类实例的类型不兼容——类实例带有原型链信息，而普通对象只是结构匹配但没有类的实例特征，直接赋值会触发编译错误。解决这个问题的核心是将对象数据映射为类实例：

基础方案：通过构造函数手动实例化 #

假设你的类定义如下：

class Tree {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
}

class Forest {
  trees: Tree[];
  constructor(trees: Tree[]) {
    this.trees = trees;
  }
}

对于字面量对象myObj：

const myObj = { trees: [{ name: "Oak" }, { name: "Pine" }] };

不能直接赋值，需要通过构造函数将每个子对象转为Tree实例，再创建Forest实例：

const forest = new Forest(myObj.trees.map(treeData => new Tree(treeData.name)));

优化方案：给类添加静态工厂方法 #

为了更优雅地处理对象转实例，可以给类添加fromJSON这类静态方法，封装实例化逻辑：

class Tree {
  name: string;
  constructor(name: string) {
    this.name = name;
  }

  // 从对象数据创建Tree实例
  static fromJSON(data: { name: string }): Tree {
    return new Tree(data.name);
  }
}

class Forest {
  trees: Tree[];
  constructor(trees: Tree[]) {
    this.trees = trees;
  }

  // 从对象数据创建Forest实例
  static fromJSON(data: { trees: { name: string }[] }): Forest {
    return new Forest(data.trees.map(Tree.fromJSON));
  }
}

// 使用方式
const forest = Forest.fromJSON(myObj);

二、Tree子类的判别与实例化 #

如果Tree有多个子类（比如OakTree、PineTree），需要通过对象中的标识字段（比如type）来判断使用哪个子类实例化，核心是实现一个工厂函数：

1. 定义子类并添加静态工厂方法 #

class Tree {
  name: string;
  type: string; // 用于区分子类的标识字段
  constructor(name: string, type: string) {
    this.name = name;
    this.type = type;
  }
}

class OakTree extends Tree {
  leafShape: string;
  constructor(name: string, leafShape: string) {
    super(name, "oak");
    this.leafShape = leafShape;
  }

  static fromJSON(data: { name: string; leafShape: string }): OakTree {
    return new OakTree(data.name, data.leafShape);
  }
}

class PineTree extends Tree {
  needleLength: number;
  constructor(name: string, needleLength: number) {
    super(name, "pine");
    this.needleLength = needleLength;
  }

  static fromJSON(data: { name: string; needleLength: number }): PineTree {
    return new PineTree(data.name, data.needleLength);
  }
}

2. 实现子类判别工厂函数 #

function treeFactory(data: { type: string; name: string } & ({ leafShape: string } | { needleLength: number })): Tree {
  switch (data.type) {
    case "oak":
      return OakTree.fromJSON(data as { name: string; leafShape: string });
    case "pine":
      return PineTree.fromJSON(data as { name: string; needleLength: number });
    default:
      throw new Error(`未知树类型：${data.type}`);
  }
}

3. 更新Forest的fromJSON方法 #

class Forest {
  trees: Tree[];
  constructor(trees: Tree[]) {
    this.trees = trees;
  }

  static fromJSON(data: { trees: Array<{ type: string; name: string } & ({ leafShape: string } | { needleLength: number })> }): Forest {
    return new Forest(data.trees.map(treeFactory));
  }
}

// 使用示例
const myObj = {
  trees: [
    { type: "oak", name: "大橡树", leafShape: "掌状分裂" },
    { type: "pine", name: "高松树", needleLength: 5 }
  ]
};

const forest = Forest.fromJSON(myObj);

关于接口的误区 #

接口仅在编译阶段做类型校验，编译后会被移除，无法帮你创建带有原型链的类实例。如果你的业务需要类的方法、原型属性等特征，必须通过类实例化来实现；接口可以用来定义对象的结构约束，但不能替代类实例化的过程。

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