时间戳

首页 > 解决方案 > 打字稿循环类型交集

typescript - 打字稿循环类型交集

问题描述

我试图为经常性交集定义一个类型定义，以实现这种行为：

type merged = Merged<[{a: string}, {b: string}, ...]>

成为{a: string} & {b: string} & ...

我定义了一些类型实用程序，例如Head并且Tail能够对可变数量的输入类型进行操作并设法定义循环联合，但未能为交集实现相同的效果:(

type Head<T extends any[]> = T[0]
type Tail<T extends any[]> =
((...args: T) => any) extends ((_arg0: any, ...rest: infer R) => any) ? R : never

type United<T extends any[]> = {
  0: Head<T>
  1: United<Tail<T>>
}[ T extends ([] | [any])
  ? 0
  : 0 | 1
]

type Merged<T extends any[]> = {
  0: Head<T>
  1: Merged<Tail<T>>
}[T extends ([] | [any])
  ? 0
  : 0 & 1
]

type a = {a: string}
type b = {b: string}
type c = {c: string}

type head = Head<[a, b, c, d]>       // {a: string} OK
type tail = Tail<[a, b, c, d]>       // [b, c]      OK
type united = United<[a, b, c, d]>   // a | b | c   OK
type merged = Merged<[a, b, c, d]>   // unknown     Not good

我一定在 TypeScript 的一些基本内部方面失败了，但不知道为什么它在联合的情况下有效，而在交集的情况下却没有？

我该如何解决呢？

标签： typescriptconditional-types

解决方案

我不会尝试在这里做任何递归，尤其是因为不支持这种递归索引。

此外，键类型的交集几乎总是会折叠成类似的东西never，因此会从中得到never或unknown或不受欢迎的东西。也就是说，索引访问不一定分布在交叉点上：

type OOPS = { a: a, b: b }["a" & "b"] // never! not a & b

相反，我会使用此处提供的解决方案来获取联合并将其转换为交集：

type Merged<A extends readonly any[]> =
    A[number] extends infer U ?
    (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ?
    I : never : never;


type a = { a: string }
type b = { b: string }
type c = { c: string }
type d = { d: string }
type merged = Merged<[a, b, c, d]>   // a & b & c & d

那应该对你有用。希望能帮助到你; 祝你好运！

链接到代码

推荐阅读