如何声明可变数量参数类型的交集类型

Question

I have a function merge that accepts a variable amount of object as arguments and creates a new object with a type which is the intersection of the argument types, kind of Object.assign() , so merge({ a: 1 }, { b: 2 })将返回一个 object 类型为{ a: number, b: number} 。

想象一下这样的实现：

function merge(...objects) {
  // Something like
  return Object.assign({}, ...objects)
}

我正在寻找一种声明其类型的方法，该方法允许我将类型信息保留在返回的 object 中。

我只能想象像这样重载定义：

function merge<A>(a: A): A;
function merge<A, B>(a: A, b: B): A & B;
function merge<A, B, C>(a: A, b: B, c: C): A & B & C;
// etc.

鉴于此 function 预计将与超过五个 arguments 一起调用，这并不方便。

谢谢！

Answer 1

您可以将与 rest 参数的元组类型对应的单个类型参数T用于merge() 。 然后你需要想出一种方法来获取一个元组类型并计算其所有元素类型的交集。 我们称该类型为 function IntersectArrayElements<T> 。 所以merge()看起来像：

function merge<T extends any[]>(
  ...objects: T
): IntersectArrayElements<T> {
  return Object.assign({}, ...objects)
}

现在我们只需要实现IntesectArrayElements<T> 。 做这件事有很多种方法：

---

一个相对简单的实现是编写一个使用可变元组类型的递归条件类型：

type IntersectArrayElements<T extends any[]> =
  T extends [infer F, ...infer R] ? F & IntersectArrayElements<R> : unknown;

它将元组T拆分为其第一个元素F和元组 R 的R ，然后结果是F与IntersectArrayElements<R> ，如果T已经为空（或数组而不是元组），则生成被所有交叉路口吸收的unknown类型。

---

如果你有很长的元组，上面的实现可能会达到递归限制（比如 25 或 50 或 100 个元素）。 对上述 TypeScript 4.5+ 的改进是将其重写为尾递归类型 function ，其中 Z558B544CF685F39D34E4903E39C38B6710 可以更有效地处理

type IntersectArrayElements<T extends any[], A = unknown> =
  T extends [infer F, ...infer R] ? IntersectArrayElements<R, A & F> : A;

这本质上是相同的算法，除了它将结果收集在累加器类型参数A中。

---

递归实现可能是最容易理解的，但递归可能有点昂贵，尤其是与其他本身可能是递归的类型函数一起使用时。 如果您可以在没有递归的情况下实现某些东西，那么最好这样做。 并且有一种无需递归即可编写IntersectArrayElements<T>的方法，尽管方式不太明显：

type IntersectArrayElements<T extends any[]> = {
  [I in keyof T]: (x: T[I]) => void
}[number] extends (x: infer I) => void ? I : never;

这首先将元组映射到一个新形式，其中每个元素都成为 function 的参数类型。 所以[{a: string}, {b: number}]变成[(x: {a: string})=>void, (x: {b: number})=>void] 。 然后我们用number 索引它以获得这些函数的联合......所以现在我们有((x: {a: string})=>void)|((x: {b: number})=>void) 。 由此我们使用条件类型推断来推断该函数联合的单个参数类型。 因为 function 类型的参数类型是逆变的，编译器推断出一个交集而不是一个联合......所以现在我们有了{a: string} & {b: number} 。 很简单，对吧？

---

对于这三个实现中的任何一个，使用merge()将观察到以下行为：

const a = { a: "hello" };
const b = { b: 123 };
const c = { c: true };

const mA = merge(a); // {a: string}
const mAB = merge(a, b); // {a: string} & {b: number}
const mABC = merge(a, b, c); // {a: string} & {b: number} & {c: boolean}
const mAandBorC = 
  merge(a, Math.random() < 0.5 ? b : c) // {a: string} & ({b: number} | {c: boolean})

这看起来像你想要的，万岁！

---

一个小警告：当您使用一组 arguments 调用merge()时，这将很好地工作，其顺序和类型对于编译器是已知的。 如果编译器无法确定 arguments 的确切数量和顺序，那么您可能会得到不太理想的 output 类型：

const forgotOrder = [a, b];
const mOops = merge(...forgotOrder);

这里， forgotOrder推断的类型是无序数组类型Array<{a: string} | {b: number}> Array<{a: string} | {b: number}> 。 通过我们称为merge()的类型，编译器不知道forgotOrder中有多少元素，也不知道{a: string}和{b: number}元素是否都存在。 所以mOops的类型是IntersectArrayElements<Array<{a: string} | {b: number}>> IntersectArrayElements<Array<{a: string} | {b: number}>> ，即{a: string} | {b: number} {a: string} | {b: number}本身或可能unknown ，具体取决于您在上面使用的实现。 目前尚不清楚这种奇怪的电话应该是什么类型，所以这就是为什么我会说这是次要的。 可以尝试针对这种情况加强merge() ，但对于所提出的问题，它可能超出了 scope 的范围。

Playground 代码链接