typescript - TS中的keyof数组类型很奇怪

Question

interface PPP {
  1: number
  2: string
  4: boolean
}

type Map1<T extends any[]> = {[K in keyof T]: T[K] extends keyof PPP ? PPP[T[K]] : never}
type Map2<T extends any[], U extends keyof T> = {[K in U]: T[K] extends keyof PPP ? PPP[T[K]] : never}

type Y1 = Map1<[1, 2]> // type Y1 = [number, string]
type Y2 = Map2<[1, 2], keyof [1, 2]> // type Y2 is not same as Y1
// type Y2 = {
//     [x: number]: string | number;
//     0: number;
//     1: string;
//     length: string;
//     toString: never;
//     toLocaleString: never;
//     pop: never;
//     push: never;
//     concat: never;
//     join: never;
//     reverse: never;
//     shift: never;
//     slice: never;
//     sort: never;
//     ... 20 more ...;
//     flat: never;
// }

就我对 TS 的了解，我认为 Map1 等同于 Map2，但是 Y1 与 Y2 不同，所以一定有一些我不知道的东西。

问题:造成这种差异的原因是什么。

Answer 1

Typescript 在构建时运行类型检查，而不是运行时。请考虑以下事项:

const a: (1 | 2 | 4)[] = [1, 1, 1, 1, 1]
const b: (1 | 2 | 4)[] = [1, 2, 4]

a 和 b 都是有效的(因为它们是包含 1、2 项的数组> 或 4。

typescript 上的

keyof T 列出了 T 类型的所有属性。对于数组，您还可以运行 array.toString() 或 array.push()。因此，toString 和 push 显示为有效时间。

Typescript 永远无法在编译时将数组中的项目列为您的类型。

---

更新

确实，关于 keyof T 从类型参数到类型值中的 keyof T 之间的不同行为，typescript 上确实存在一个错误。 Bug link

不过，您可以使用 Exclude

绕过这个问题

Link for the playground

interface PPP {
  1: number
  2: string
  4: boolean
}

type Map1 < T extends any[] > = {
  [K in keyof T]: T[K] extends keyof PPP ? PPP[T[K]] : never
}
type Map2 < T extends any[], U extends keyof T > = {
  [K in U]: T[K] extends keyof PPP ? PPP[T[K]] : never
}

type Map3 < T extends any[], U extends keyof T > = {
  [K in Exclude < U, keyof any[] > ]: T[K] extends keyof PPP ? PPP[T[K]] : never
}




type Y1 = Map1 < [1, 2] > // type Y1 = [number, string]
  type Y2 = Map2 < [1, 2], keyof[1, 2] > // type Y2 is not same as Y1
  type Y3 = Map3 < [1, 2], keyof[1, 2] > // Same as Y3