如何避免重复书写多个泛型类型参数？

你遇到的是TypeScript泛型参数复用的常见问题，直接用...展开元组作为泛型参数的语法目前不被支持，这里有几种实用的替代方案：

1. 给函数添加泛型参数 #

把函数本身声明为泛型，一次性定义好需要复用的类型参数，后续直接在函数内部的类型标注中使用：

type Type1<A, B, C> = { a: A; b: B; c: C };
type Type2<A, B, C> = [A, B, C];
type Type3<A, B, C> = (a: A, b: B, c: C) => void;

// 函数泛型定义一次参数
function f<A, B, C>(x: Type1<A, B, C>) {
  const y: Type2<A, B, C> = [x.a, x.b, x.c];
  const z: Type3<A, B, C> = (a, b, c) => console.log(a, b, c);
}

// 调用时可自动推导参数类型，也可显式指定
f<ComplexParam1, ComplexParam2, ComplexParam3>({ a: ..., b: ..., c: ... });

这种方案最简洁，TypeScript会根据传入的x自动推导泛型参数，无需手动重复书写。

2. 定义元组转泛型的辅助类型 #

如果需要固定参数组合（比如ComplexParams），可以写辅助类型把元组拆解为对应泛型参数：

type ComplexParams = [ComplexParam1, ComplexParam2, ComplexParam3];

// 针对你的三个类型分别写辅助类型
type Type1FromTuple<T extends [any, any, any]> = Type1<T[0], T[1], T[2]>;
type Type2FromTuple<T extends [any, any, any]> = Type2<T[0], T[1], T[2]>;
type Type3FromTuple<T extends [any, any, any]> = Type3<T[0], T[1], T[2]>;

// 使用时直接传入元组类型
function f(x: Type1FromTuple<ComplexParams>) {
  const y: Type2FromTuple<ComplexParams> = ...;
  const z: Type3FromTuple<ComplexParams> = ...;
}

如果需要更通用的辅助类型，也可以写一个适配任意三元泛型的版本：

type ApplyTripleGeneric<T extends [any, any, any], G<A, B, C>> = G<T[0], T[1], T[2]>;

// 使用示例
function f(x: ApplyTripleGeneric<ComplexParams, Type1>) {
  const y: ApplyTripleGeneric<ComplexParams, Type2> = ...;
  const z: ApplyTripleGeneric<ComplexParams, Type3> = ...;
}

3. 单独定义参数类型别名 #

如果参数组合是固定的，直接把每个参数存为单独的类型别名，后续复用：

// 把复杂参数单独定义
type P1 = ComplexParam1;
type P2 = ComplexParam2;
type P3 = ComplexParam3;

function f(x: Type1<P1, P2, P3>) {
  const y: Type2<P1, P2, P3> = ...;
  const z: Type3<P1, P2, P3> = ...;
}

这种方案适合参数组合长期固定的场景，可读性高。

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