Typescript 如何正确地对类型脚本泛型进行限制

我认为表达这一点的最直接的方法是将generic个类型参数分成两个. 你可以有A，所有策略都通用的参数列表类型，T，从策略键到相应策略的返回类型的映射. 给定这些类型，那么strategies就是

type Strategies<A extends any[], T> =
  { [K in keyof T]: (...args: A) => T[K] }

它是一个将T中的每个成员转换成返回该成员的函数的mapped type.

以下是我对CascadeStrategies的概率:

class CascadeStrategies<A extends any[], T extends object> {
  private strategies!: Strategies<A, T>

  constructor(strategyMap:
    Record<string, (...args: A) => any> &
    Strategies<A, T>
  ) {
    this.registerStrategies(strategyMap);
  }

  private registerStrategies(strategyMap: Strategies<A, T>) {
    this.strategies = strategyMap;
  }

  use<K extends keyof T>(
    strategies: K[],
    ...args: A
  ) {
    return this.strategies[strategies[0]](...args); // okay
  }
}

编译时没有错误.这里最重要的部分是use()里面发生的事情. 现在这个函数在K中是泛型的，键为T. 返回类型use()根据需要推断T[K].

请注意，为了使其工作，我们需要TypeScript在编写new CascadeStrategies(myMap)时推断出A和T. 推理可能很棘手.我的方法是使构造函数参数的类型为Record<string, (...args: A) => any> & Strategies<A, T>. 这是一个intersection，其中每个片段帮助推断出一个不同类型的论点. Record<string, (...args: A) => any>类型允许推断A，因为它可以在TypeScript知道T之前发生. 然后Strategies<A, T>允许从方法的返回类型推断T. 将交叉点X & Y加宽到其成员Y中的一个总是安全的，所以我们可以处理复杂的交叉点，并将strategyMap作为类型Strategies<A, T>来处理.

让我们来测试一下:

const myMap = {
  test: (arg1: number, arg2: string) => arg1,
  otherTest: (arg1: number, arg2: string) => arg2,
  thirdTest: (arg1: number, arg2: string) => null
}
const cascadeStrats = new CascadeStrategies(myMap);
/*    ^? const cascadeStrats: CascadeStrategies<
    [arg1: number, arg2: string], 
    { test: number; otherTest: string; thirdTest: null; }
    >
*/
const shouldBeNumber = cascadeStrats.use(["test"], 0, "");
//    ^? const shouldBeNumber: number
const shouldBeString = cascadeStrats.use(["otherTest"], 0, "");
//    ^? const shouldBeString: string
const shouldBeNull = cascadeStrats.use(["thirdTest"], 0, "");
//    ^? const shouldBeNull: null
const shouldBeStringOrNumber = cascadeStrats.use(["test", "otherTest"], 0, "")
//    ^? const shouldBeStringOrNumber: string | number

cascadeStrats.use(["test"], "oops", "abc"); // error!
// -----------------------> ~~~~~~
// Argument of type 'string' is not assignable to parameter of type 'number'.

看起来不错T被正确推断，因此shouldBeXXX都是预期的类型，A也被正确推断，以便编译器注意到如果传入了错误的参数类型(如上面最后一行所示).

Playground link to code