如何递归约束TypeScript对象属性的类型？

问题回顾 #

你想要递归约束对象的属性类型，要求所有属性只能是number、string，或者符合相同规则的嵌套对象，但当前用索引签名的实现需要在每个类里添加额外代码，还会影响类型推断。你的现有代码是这样的：

type AllowedTypes = string | number | ConstrainedClass;
type ConstrainedClass = { [key: string]: AllowedTypes };
class Test2 {
    [key: string]: AllowedTypes; // 必须添加这行
    public prop1: number;
}
class Test1 {
    [key: string]: AllowedTypes; // 必须添加这行
    public prop1: string;
    public prop2: number;
    public nestedProp: Test2;
}
function somefunction<T extends ConstrainedClass>(param: T) {
    return;
}
somefunction(new Test1());

确实，索引签名的方式虽然能实现约束，但带来的副作用挺烦人的。下面是几个更优的解决方案，你可以根据自己的需求和TypeScript版本来选：

方案1：用satisfies关键字（TypeScript 4.9+ 推荐） #

如果你已经升级到TS 4.9或更高版本，satisfies绝对是最佳选择。它能帮你验证类型是否符合约束，同时完全保留原有的类型推断，不需要修改类的定义。

首先定义递归约束类型：

// 递归约束：属性只能是string/number，或者符合该规则的嵌套对象
type RecursiveConstrainedType = 
  | string 
  | number 
  | { [key: string]: RecursiveConstrainedType };

然后在创建类实例的时候，用satisfies来验证：

class Test2 {
  public prop1: number;
}
// 验证Test2实例符合约束，同时保留Test2的原有类型
const test2 = new Test2() satisfies RecursiveConstrainedType;

class Test1 {
  public prop1: string;
  public prop2: number;
  public nestedProp: Test2;
}
const test1 = new Test1() satisfies RecursiveConstrainedType;

function somefunction<T extends RecursiveConstrainedType>(param: T) {
  return;
}
somefunction(test1); // ✅ 正常通过

这个方案的好处太明显了：

• 不需要给类加任何冗余的索引签名
• 类型推断完全正常，比如你访问test1.prop1，TS依然能准确知道它是string类型
• 灵活度高，你可以在需要验证的地方才用satisfies，不影响类的其他使用场景

方案2：用接口继承（类定义阶段约束） #

如果需要在类定义的时候就强制约束类型，而不是等到实例化时，可以用接口继承的方式：

// 定义递归约束接口
interface RecursiveConstrainedInterface {
  [key: string]: string | number | RecursiveConstrainedInterface;
}

// 让类实现这个接口，自动约束所有属性类型
class Test2 implements RecursiveConstrainedInterface {
  public prop1: number; // ✅ 符合约束
  // 如果加个boolean属性会直接报错：类型boolean不能赋值给string | number | RecursiveConstrainedInterface
  // public invalidProp: boolean; 
}

class Test1 implements RecursiveConstrainedInterface {
  public prop1: string;
  public prop2: number;
  public nestedProp: Test2; // Test2已经符合约束，所以没问题
}

function somefunction<T extends RecursiveConstrainedInterface>(param: T) {
  return;
}
somefunction(new Test1()); // ✅ 正常通过

这种方式相比你的原方案，不需要在每个类里重复写索引签名，只需要implements接口即可。不过要注意：类实现索引签名接口时，所有属性的类型必须严格匹配接口的类型范围，否则会直接报错。

方案3：泛型递归约束（仅函数参数验证） #

如果你的核心需求只是确保传入函数的参数符合约束，完全不需要修改类的定义，可以用泛型递归的方式在函数层面做验证：

// 泛型递归类型，用来验证对象是否符合约束
type RecursiveConstrainedCheck<T> = 
  T extends string | number ? T :
  T extends object ? { [K in keyof T]: RecursiveConstrainedCheck<T[K]> } :
  never;

// 用条件类型约束函数参数
function somefunction<T>(param: T extends RecursiveConstrainedCheck<T> ? T : never) {
  return;
}

// 类的定义完全不用改
class Test2 {
  public prop1: number;
}

class Test1 {
  public prop1: string;
  public prop2: number;
  public nestedProp: Test2;
}

somefunction(new Test1()); // ✅ 正常通过
// 传入不符合约束的对象会直接报错
somefunction({ prop: true }); // ❌ 类型错误：boolean不在允许的类型范围内

这个方案的优点是完全不侵入类的定义，只在函数参数层面做校验，适合那些类本身不需要约束，只是特定函数需要参数符合规则的场景。

方案对比 #

为了方便你选择，我整理了各个方案的优缺点：

根据自己的实际场景选就行，个人最推荐satisfies方案，只要你的TS版本够新，体验是最好的。

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