TypeScript是否支持严格子类型？如何实现泛型严格子类型约束？

在TypeScript的结构类型系统下，无法完美实现严格子类型（排除T本身）的泛型约束，你的判断是正确的。但可以通过一些技巧在特定场景下近似实现需求，下面结合你的用例详细说明：

核心限制原因 #

TypeScript采用结构类型系统，类型等价性完全基于属性结构而非类名；同时它不支持存在量化（existential quantification），无法直接表达“所有属于T的子类型但不等于T的类型”这种抽象约束。这导致我们无法绝对区分“T本身”和“与T结构完全一致的子类型”，但可以处理绝大多数实际场景中的严格子类型需求。

用例1：FamilyTree的严格子节点约束 #

可以利用条件类型的可赋值性判断，排除与T结构等价的类型：

type AnySubtypeOf<T> = 
  T extends infer U 
    ? U extends T 
      ? T extends U 
        ? never  // 类型等价时返回never，排除T本身
        : U 
      : never 
    : never;

class FamilyTree<T> {
    parent: T;
    children: AnySubtypeOf<T>[];

    constructor(familyTree: FamilyTree<T>) {
        this.parent = familyTree.parent;
        this.children = familyTree.children;
    }
}

// 测试类
class A { 
  x: number; 
  constructor(x: number) { this.x = x; } 
}

class B extends A { 
  y: number; 
  constructor(x: number, y: number) { super(x); this.y = y; } 
}

class C { 
  x: number;
  z: number; 
  constructor(x: number, z: number) { this.x = x; this.z = z; } 
}

class D { 
  w: string; 
  constructor(w: string) { this.w = w; } 
}

const a = new A(1);
const b = new B(2, 3);
const c = new C(4, 5);
const d = new D("Hey!");

new FamilyTree<A>({ parent: a, children: [ b, c ] }); // ✅ 无TS错误
new FamilyTree<A>({ parent: a, children: [ b, d ] }); // ❌ TS错误，d不是A的子类型
new FamilyTree<A>({ parent: a, children: [ b, a ] }); // ❌ TS错误，a不是A的严格子类型

注意局限 #

如果存在一个无扩展属性的子类class E extends A {}，由于它和A结构完全一致，TypeScript会认为两者等价，此时AnySubtypeOf<A>会将E也排除，这是结构类型系统的固有局限。

用例2：Monguito的DomainModel子类型约束 #

结合构造函数类型的不等性，增强类层级的约束：

// 定义严格子类型：要求S是T的子类型，且构造函数不等于T的构造函数
type AnySubtypeOf<T extends { new(...args: any[]): any }> = 
  S extends T 
    ? T extends S 
      ? never 
      : S 
    : never;

interface DomainModel<T extends { new(...args: any[]): any }> {
    type: T;
    schema: Schema<InstanceType<T>>;
    subtypes?: DomainModel<AnySubtypeOf<T>>[];
}

// 测试类
class Book {
    readonly id?: string;
    readonly title: string;
    readonly isbn: string;

    constructor(book: Book) {
        this.id = book.id;
        this.title = book.title;
        this.isbn = book.isbn;
    }
}

class PaperBook extends Book {
    readonly edition: number;
    
    constructor(paperBook: PaperBook) {
        super(paperBook);
        this.edition = paperBook.edition;
    }
}

class AudioBook extends Book {
    readonly hostingPlatforms: string[];

    constructor(audioBook: AudioBook) {
        super(audioBook);
        this.hostingPlatforms = audioBook.hostingPlatforms;
    }
}

// 正确实例化
const validConfig: DomainModel<typeof Book> = {
    type: Book,
    schema: BookSchema,
    subtypes: [
        { type: PaperBook, schema: PaperBookSchema },
        { type: AudioBook, schema: AudioBookSchema },
    ],
};

// 错误示例：尝试将Book作为子类型
const invalidConfig: DomainModel<typeof Book> = {
    type: Book,
    schema: BookSchema,
    subtypes: [
        { type: Book, schema: BookSchema }, // ❌ TS错误：Book不属于严格子类型
    ],
};

进阶优化：模拟标称类型 #

如果需要严格区分结构一致但类名不同的类型，可以给每个类添加唯一的品牌属性：

type Brand<T, B> = T & { __brand: B };

class Book {
    readonly __brand: "Book" = "Book";
    // ... 其他属性
}

class E extends Book {
    readonly __brand: "E" = "E";
}

通过这种方式，即使E和Book结构一致，TypeScript也会将它们视为不同类型，AnySubtypeOf<Book>可以正确识别E为严格子类型。

总结 #

1. 在TypeScript的结构类型系统下，无法绝对实现你想要的严格子类型约束，无法区分结构完全一致的父类型和子类型；
2. 上述条件类型方案可以覆盖绝大多数实际开发场景，排除明显不符合的类型，提升开发体验；
3. 若需要更严格的标称类型区分，可以手动添加品牌属性来模拟标称类型系统的特性。

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