如何在TypeScript中约束泛型参数为安全可比较类型？

我有一段使用标准比较运算符的泛型代码，希望将泛型类型约束为可安全比较的类型——比如string、number、boolean、Date是安全的，但string | number、null、Array<string>这类类型则不安全。现有代码示例如下：

// 期望K只能是string/number/boolean/Date
declare function sort<K>(array: Array<K>): void;
declare function max<K>(a: K, b: K): void;
class BinaryTree<K, V> { constructor(private readonly k: K) {} }

// 这些调用不应报错
function f1(r: string): void {
    sort([r, r]);
    max(r, r)
    new BinaryTree(r)
}
function f2(r: boolean): void {
    sort([r, r]);
    max(r, r)
    new BinaryTree(r)
}

// 这些调用应该报错
function f3(r: null): void {
    sort([r, r]);
    max(r, r)
    new BinaryTree(r)
}
function f4(r: string | number): void {
    sort([r, r]);
    max(r, r)
    new BinaryTree(r)
}
function f5(r: Array<string>): void {
    sort([r, r]);
    max(r, r)
    new BinaryTree(r)
}

目前的临时方案（比如指定数组类型为Array<string> | Array<number> | Array<Date> | Array<boolean>，或者用函数签名重载）过于冗长混乱，想知道能否在保留类型参数的前提下，实现这类泛型约束？

可以通过自定义泛型约束结合条件类型实现，核心思路是明确允许的安全类型集合，同时排除联合类型、null/undefined等不安全类型，确保泛型参数是单一的安全类型。具体代码如下：

// 定义允许的安全比较类型集合
type AllowedComparable = string | number | boolean | Date;

// 自定义约束：确保K是单一的AllowedComparable类型，而非联合类型或其他不安全类型
type IsStrictComparable<K> = 
  K extends AllowedComparable 
    ? [K] extends [AllowedComparable] 
      ? K 
      : never 
    : never;

// 将约束应用到泛型函数和类
declare function sort<K extends IsStrictComparable<K>>(array: Array<K>): void;
declare function max<K extends IsStrictComparable<K>>(a: K, b: K): void;
class BinaryTree<K extends IsStrictComparable<K>, V> { constructor(private readonly k: K) {} }

// 测试：正常通过（无报错）
function f1(r: string): void {
    sort([r, r]);
    max(r, r);
    new BinaryTree(r);
}
function f2(r: boolean): void {
    sort([r, r]);
    max(r, r);
    new BinaryTree(r);
}
function f6(r: Date): void {
    sort([r, r]);
    max(r, r);
    new BinaryTree(r);
}

// 测试：触发报错（符合预期）
function f3(r: null): void {
    sort([r, r]); // 报错：null不属于AllowedComparable集合
    max(r, r);
    new BinaryTree(r);
}
function f4(r: string | number): void {
    sort([r, r]); // 报错：联合类型不满足IsStrictComparable约束
    max(r, r);
    new BinaryTree(r);
}
function f5(r: Array<string>): void {
    sort([r, r]); // 报错：Array<string>不属于AllowedComparable集合
    max(r, r);
    new BinaryTree(r);
}

原理说明 #

• AllowedComparable：明确列出所有支持安全比较的基础类型，作为校验的基准
• IsStrictComparable<K>：通过[K] extends [AllowedComparable]的写法规避TypeScript的分布式条件类型特性——如果K是联合类型，该条件会返回false，从而将联合类型排除；同时确保K必须是AllowedComparable的子类型，直接过滤null、数组等不安全类型
• 将K extends IsStrictComparable<K>作为泛型约束，就能在保留泛型参数灵活性的前提下，实现严格的类型校验

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