困惑：为何无法将泛型约束类型的具体值赋值给泛型类的泛型属性？

我完全懂你现在的困惑——明明泛型I是继承自TypeFIIM的，那TypeFIIM类型的FIIM为啥不能赋值给I类型的myTypes呢？这看起来好像不合逻辑，但其实TypeScript的泛型约束在这里的考量比你想的更严谨，咱们一步一步理清楚。

核心问题：泛型I是「子类型」，但父类型值不一定能满足子类型要求 #

你可能误以为「只要I是TypeFIIM的子类型，那TypeFIIM类型的值就可以赋值给I」，但这个逻辑是反过来的：子类型的值可以赋值给父类型，但父类型的值不一定能赋值给子类型。

TypeScript的泛型约束I extends TypeFIIM只保证「I至少拥有TypeFIIM的所有属性」，但I完全可以是一个更严格、更具体的类型——它可能有额外的属性，或者它的属性是更窄的字面量类型。这时候把父类型的TypeFIIM值塞给I类型的变量，就会出现类型不匹配的问题。

举个简单的反例 #

先脱离你的代码，看个更直观的例子：

// 父类型
interface Animal { name: string; }
// 子类型，比父类型多了一个属性
interface Dog extends Animal { breed: string; }

// 泛型类
class Pet<T extends Animal> {
  animal: T;

  constructor() {
    // 这里会报错：Type 'Animal' is not assignable to type 'T'
    this.animal = { name: "无名动物" };
  }
}

如果有人用new Pet<Dog>()实例化这个类，animal的类型是Dog，它需要breed属性，但你给的Animal值没有这个属性——这就是TypeScript报错的核心原因：它要保证你的代码在所有可能的泛型实例化场景下都合法，哪怕这个场景是你没考虑到的子类型。

回到你的代码场景 #

再看你的具体例子：
你定义了TypeFRPIM作为TypeFIIM的子类型，多了Transform属性。如果有人实例化MyClass<TypeFRPIM>，那myTypes的类型是TypeFRPIM，它需要有Transform属性，但你在父类构造函数里给的FIIM是没有这个属性的——这就直接不匹配了！

你可能会说「我在子类里重写了myTypes啊」，但父类的构造函数是在子类继承时一定会执行的，TypeScript不会因为子类重写了属性就放松对父类代码的类型检查——它要保证父类的代码逻辑本身是类型安全的。

另外，第二个报错Type 'string' is not assignable to type 'I[keyof I]'也是同理：如果有一个子类型重写了Literal属性的类型，比如：

interface CustomType extends TypeFIIM {
  readonly Literal: "custom-literal";
}

那当I是CustomType时，myType的类型是"custom-literal"，但你给的FIIM.Literal是"literal"，这就完全不匹配了。

解决办法 #

方案1：让泛型类接收外部传入的I类型值（推荐） #

最安全的方式是把I类型的值的创建交给调用者（比如子类），父类只负责接收和使用：

// Types for Parent Class
type TypeFIIM = {
  readonly Literal: 'literal';
  readonly Resource: 'resource';
}
const FIIM: TypeFIIM = {
  Literal: 'literal',
  Resource: 'resource',
} as const;

// Type for Child Subclass
interface TypeFRPIM extends TypeFIIM {
  readonly Transform: 'transform';
}
const FRPIM: TypeFRPIM = {
  ...FIIM,
  Transform: 'transform',
} as const;

class MyClass<I extends TypeFIIM> {
  protected myTypes: I;
  protected myType: I[keyof I];

  constructor(types: I) {
    this.myTypes = types;
    // 现在没问题，因为types是严格的I类型
    this.myType = this.myTypes.Literal;
  }
}

class MySubclass extends MyClass<TypeFRPIM> {
  constructor() {
    // 子类传入自己的TypeFRPIM类型值
    super(FRPIM);
    // 子类可以重写myType
    this.myType = this.myTypes.Transform;
  }
}

这种方式完全符合TypeScript的类型安全要求，同时也保留了子类的扩展性。

方案2：使用类型断言（不推荐，牺牲类型安全） #

如果你一定要在父类里设置默认值，可以用类型断言跳过检查，但要注意这会带来运行时风险：

class MyClass<I extends TypeFIIM> {
  // 用类型断言强制赋值
  protected myTypes: I = FIIM as unknown as I;
  protected myType: I[keyof I] = this.myTypes.Literal as unknown as I[keyof I];
}

但这种方式的问题是：当I是一个需要额外属性的子类型时，myTypes实际上是没有这些属性的，运行时访问这些属性会报错。

总结 #

TypeScript的这个报错不是吹毛求疵，而是在帮你预防潜在的类型不匹配问题。核心逻辑是：

泛型约束I extends T只保证I是T的子类型，但不保证T是I的子类型——子类型可以比父类型要求更多的属性或更严格的类型，父类型的值不一定能满足这些要求。

内容来源于stack exchange