如何基于对象数组属性关联约束对应属性类型？TypeScript问题

我正在实现一个基于构造函数传入规则的简易解析器，代码逻辑运行正常，但存在类型约束问题。

原代码如下：

interface RuleBase {
  parse(text: string, params: Record<string, any>): string;
}

class RuleA implements RuleBase {
  parse(text: string, params: { a: 'aa' }) {
    // parse rules
    return '';
  }
}

class RuleB implements RuleBase {
  parse(text: string, params: { b: 'bb' }) {
    // parse rules
    return '';
  }
}

class Parser<T extends Record<string, RuleBase>> {
  private parserRules: T;

  constructor(parserRules: T) {
    this.parserRules = parserRules;
  }

  parse(text: string, rules: { ruleName: keyof T; params: Parameters<T[keyof T]['parse']>[1] }[]) {
    let result = text;

    rules.forEach(({ ruleName, params }) => {
      const rule = this.parserRules[ruleName];
      if (rule) result = rule.parse(result, params);
    });

    return result;
  }
}

使用示例：

const parser = new Parser({
  a: new RuleA(),
  b: new RuleB(),
});

// 符合预期（正常情况）
parser.parse('Example1', [
  { ruleName: 'a', params: { a: 'aa' } },
  { ruleName: 'b', params: { b: 'bb' } },
]);
parser.parse('Example2', [
  { ruleName: 'b', params: { b: 'bb' } },
]);

// 不符合预期：规则'b'仅需参数'b'，此处不应允许多余参数
parser.parse('Example3', [
  { ruleName: 'b', params: { a: 'aa', b: 'bb' } },
]);

// 不符合预期：规则'a'仅需参数'a'，规则'b'仅需参数'b'，不应允许多余参数
parser.parse('Example4', [
  { ruleName: 'a', params: { a: 'aa', b: 'bb' } },
  { ruleName: 'b', params: { a: 'aa', b: 'bb' } },
]);

问题点：在Example3和Example4的调用中，规则对应的参数允许传入多余字段，不符合预期。需要在不改变核心逻辑的前提下解决类型约束问题。

问题根源 #

1. RuleBase接口中params定义为Record<string, any>，导致实现类的params类型被宽泛化，TypeScript的逆变特性会允许子类参数是父类的子集，但无法限制多余字段。
2. Parser.parse方法中params的类型是Parameters<T[keyof T]['parse']>[1]，这里keyof T会联合所有规则的参数类型，导致参数接受所有规则参数的并集，无法做到规则名与参数的一对一严格匹配。

修改后的代码 #

通过泛型映射和严格类型约束实现规则名与参数的精确对应，同时限制参数只能是精确类型：

// 泛型RuleBase，明确每个规则的参数类型
interface RuleBase<P extends object> {
  parse(text: string, params: P): string;
}

class RuleA implements RuleBase<{ a: 'aa' }> {
  parse(text: string, params: { a: 'aa' }) {
    // parse rules
    return '';
  }
}

class RuleB implements RuleBase<{ b: 'bb' }> {
  parse(text: string, params: { b: 'bb' }) {
    // parse rules
    return '';
  }
}

// 构建规则名到参数类型的映射
type RuleMap = Record<string, RuleBase<any>>;
type RuleParams<T extends RuleMap> = {
  [K in keyof T]: T[K] extends RuleBase<infer P> ? P : never;
};

// 修改Parser类，关联规则名与对应参数类型
class Parser<T extends RuleMap> {
  private parserRules: T;

  constructor(parserRules: T) {
    this.parserRules = parserRules;
  }

  // 泛型重载：让每个规则项的参数与规则名严格匹配
  parse<U extends Array<{ ruleName: keyof T; params: RuleParams<T>[U[number]['ruleName']] }>>(
    text: string,
    rules: U
  ): string;
  // 实现签名：保证逻辑正常运行，内部用类型断言兼容循环中的推断局限
  parse(text: string, rules: Array<{ ruleName: keyof T; params: RuleParams<T>[keyof T] }>): string {
    let result = text;

    rules.forEach(({ ruleName, params }) => {
      const rule = this.parserRules[ruleName];
      if (rule) result = rule.parse(result, params as any);
    });

    return result;
  }
}

代码解释 #

1. 泛型RuleBase：将接口改为带参数类型P的泛型，让每个规则类明确自己的参数结构，避免any导致的类型模糊。
2. RuleParams映射：通过infer提取每个规则对应的参数类型，构建规则名到参数的精确映射表。
3. 重载parse方法：用泛型数组重载实现外部调用时的严格类型校验，确保每个规则项的params与ruleName完全匹配；实现签名保留原逻辑，内部的as any是因为TypeScript无法在循环中精确推断每个迭代的参数类型，但外部调用的类型校验已经生效。

效果验证 #

修改后，Example3和Example4的调用会直接触发TypeScript编译错误：

• Example3中params: { a: 'aa', b: 'bb' }会提示类型不匹配，无法赋值给{ b: 'bb' }。
• Example4中规则a的参数包含b字段也会触发类似错误。

正常调用（Example1、Example2）则可以顺利通过类型校验，完全符合预期。

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