TypeScript泛型数组展开与赋值类型问题咨询

一、基础场景的类型矛盾 #

以下代码会抛出类型错误：

const spread = <T extends unknown[]>(arr: T): T => [...arr]; 
// 错误：'T[number][]' is not assignable to type 'T'

核心原因 #

T extends unknown[]的约束过于宽泛——它既包含普通数组（如string[]），也包含元组（如[string, number]）。展开操作[...arr]的结果类型是T[number][]（即由T的元素类型组成的普通数组），但元组类型的长度、元素顺序是固定的，普通数组无法匹配元组的精确类型。比如若T是[string, number]，[...arr]的类型是(string | number)[]，显然不等于原元组类型。

约束宽松的副作用 #

以下示例暴露了unknown[]约束的不合理性：

const test = <T extends unknown[]>(arr:T):T[number]=>arr[0] // 无错误（合理）
const test2 = <T extends unknown[]>(arr:T):T[number]=>[...arr] // 无错误（不合理）

test2中返回的数组类型T[number][]本应与返回值类型T[number]（单个元素类型）不兼容，但TypeScript因unknown[]的宽松约束无法准确推断，导致错误被遗漏。

二、临时解决方案的疑问 #

以下两种写法可以绕过错误，但背后的逻辑需要明确：

1. 元组约束写法 #

const tupleSpread = <T extends readonly [unknown,...unknown[]]>(arr: T): T => [...arr]; // 无错误

这个约束将T限制为元组类型（readonly [unknown,...unknown[]]表示任意长度的元组）。TypeScript对元组的展开操作有特殊处理：当泛型明确约束为元组时，展开后的结果会被推断为原元组类型，而非普通数组，因此可以赋值回T。但这种写法仅适用于元组场景，无法覆盖普通数组。

2. Object.assign写法 #

const spreadAssign = <T extends unknown[]>(arr: T): T => Object.assign(arr); // 无错误

这里的本质是偷换概念：Object.assign(arr)仅返回原数组的引用（未创建新数组），TypeScript的类型定义中，Object.assign会直接返回第一个参数的类型T，因此不会触发类型错误。但这并没有实现真正的数组展开复制，只是利用了类型系统的特性绕过错误。

三、业务场景中的具体问题 #

业务代码中遇到的类型错误与基础场景同源：

type DataMap = {
  string: string;
  number: number;
};

type ArrayMap = { [K in keyof DataMap]: DataMap[K][] };

const apply = <T extends keyof DataMap>(
  target: ArrayMap[T],
  payload: DataMap[T]
): ArrayMap[T] => {
  const next = [...target, payload]; // 类型为 (DataMap[T] | ArrayMap[T][number])[]
  return next; // 错误：无法赋值给 ArrayMap[T]
};

TypeScript无法推断ArrayMap[T][number]等价于DataMap[T]（尽管逻辑上ArrayMap[T]就是DataMap[T][]），导致next被推断为联合类型数组，无法匹配返回值类型DataMap[T][]。

尝试绕过的局限性 #

调整泛型写法后，错误被延后到调用阶段：

const applyByValueType = <T extends DataMap[keyof DataMap]>(
  target:  T[],
  payload: T
): T[] => {
  return [...target, payload];
};

const unitArrays:ArrayMap={
  number:[],
  string:[]
}

const applyAny = <T extends keyof DataMap> (discriminant:T,unit:DataMap[T])=>{
  const target = unitArrays[discriminant];
  const next = applyByValueType(target, unit);
  unitArrays[discriminant] = next; // 错误：类型不兼容
}

applyByValueType返回的T[]类型是(string | number)[]（因为T是string | number），而unitArrays[discriminant]的类型是string[]或number[]，联合类型数组无法赋值给具体类型数组。

四、元组类型的测试困惑 #

定义元组类型后，单独赋值正常，但组合后无法匹配：

type AcceptableTuple = { [K in keyof DataMap]:  [ DataMap[K][], DataMap[K]] };

const applyAnyAcceptable = <T extends keyof DataMap> (discriminant:T,unit:DataMap[T])=>{
  const target = unitArrays[discriminant];

  const isTargetAcceptable:AcceptableTuple[T][0]=target; // 正常
  const isUnitAcceptable:AcceptableTuple[T][1]=unit; // 正常

  const areBothAcceptable:[AcceptableTuple[T][0],AcceptableTuple[T][0]]=[target,unit] // 错误
  const areBothAccetpable2:AcceptableTuple[T] = [target,unit] as const // 错误
  const areBothAccetpableObject:AcceptableTuple[T] = Object.assign([target,unit]) // 正常
}

• 单独赋值正常是因为target和unit的类型分别精确匹配AcceptableTuple[T][0]和AcceptableTuple[T][1]。
• 组合成元组时，[target, unit]的类型被推断为(DataMap[T][] | DataMap[T])[]（普通数组），无法匹配固定长度的元组类型AcceptableTuple[T]。
• Object.assign能生效的原因是其返回类型为第一个参数的类型（(DataMap[T][] | DataMap[T])[]），而TypeScript允许普通数组赋值给元组类型（元组是数组的子类型，反向赋值存在放宽），但这并非类型安全的写法。

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