TypeScript 中的交集和合并类型 `{ foo } & { bar }` 和 `{ foo, bar }` 之间的区别

Question

考虑类型FooBar1和FooBar2定义如下：

type Foo = { foo: string };
type Bar = { bar: number };
type FooBar1 = Foo & Bar;
type FooBar2 = { foo: string; bar: number };

问题：FooBar1和FooBar2有什么区别？

---

我的尝试/研究：

• 它们可以双向分配给彼此！ （手动检查并使用tsd - see here）
• 不过，它们彼此并不相同！ （检查tsd - see here）
• VSCode 的智能感知不会自动将{ foo } & { bar } 折叠成{ foo, bar }，但它确实会将其他复杂类型折叠成更简单的形式，例如将NonNullable<string | undefined> 折叠成string：

// |------------------------------------------------------------|
// | let x: {                                                   |
// |     a: string;                                             |
// | } & {                                                      |
// |     b: string;                                             |
// | }                                                          |
// | -----------------------------------------------------------|
//  ^
//  | When hovering `x` here:
//  |
let x: { a: string } & { b: string };

---

编辑： Difference between extending and intersecting interfaces in TypeScript? 已被建议重复，但我不同意。我不是将交集与接口的扩展进行比较，而是将交集与另一种原始类型进行比较，不涉及接口或扩展。

Answer 1

在您的示例中，我们可以说FooBar1 和FooBar2 是相等的。我们确实可以证明：

type Equals<A, B> =
    A extends B
    ? B extends A
      ? true
      : false
    : false

type test0 = Equals<{a: 1} & {b: 2}, {a: 1, b: 2}> // true

但对于一般的答案，我们只能说它们并不总是相等的。为什么？因为在某些情况下，交叉点可以解析为never。如果 ts 发现一个交集是有效的，它会继续它，否则返回never。

import {O} from "ts-toolbelt"

type O1 = {a: 1, b: 2}
type O2 = {a: 1} & {b: 2}       // intersects properly
type O3 = {a: 1, b: 2} & {b: 3} // resolved to `never`

type test0 = Equals<O1, O2>
// true

type test1 = O.Merge<{a: 1, b: 2}, {b: 3, c: 4}>
// {a: 1, b: 2, c: 4}

在这里键入O3 解析为never，因为b 是3，它不能与2 重叠。让我们更改我们的示例，以表明如果您有交叉路口将起作用：

import {A} from "ts-toolbelt"

type O4 = A.Compute<{a: 1, b: number} & {b: 2}> // {a: 1, b: 2}
type O5 = A.Compute<{a: 1, b: 2} & {b: number}> // {a: 1, b: 2}

这个例子还强调了交叉点的工作原理——比如联合交叉点。 TypeScript 将遍历所有属性类型并将它们相交。我们已经强制 TypeScript 计算与A.Compute 相交的结果。

简而言之，如果 ts 不能与所有成员重叠，则该交集的乘积为never。因此，它可能不适合作为合并工具：

type O3 = {a: 1, b: 2} & {b: 3} // resolved to `never`

请记住，& 不是合并工具。 A & B 仅等于 {...A, ...B} 仅当它们具有不重叠的键时。如果需要合并类型，请使用O.Merge。