交集和合并类型“{ foo }”之间的区别

Question

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

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

我的尝试/研究：

• 它们是双向相互分配的！（手动检查并使用TSD检查 - 请参阅此处）
• 不过，它们彼此并不完全相同！（与TSD检查 - 见这里）
• VSCode 的智能感知不会崩溃 { foo }

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

编辑：TypeScript中扩展和交叉接口之间的区别？已被建议为重复，但我不同意。我不是在将交集与接口的扩展进行比较，而是将交集与另一种原始类型进行比较，不涉及接口或扩展。




Answer 1

匿名用户

在您的示例中，我们可以说< code>FooBar1和< code>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

但是对于一个笼统的回答，我们只能说，它们并不总是相等的。为什么？因为在某些情况下，交集可以解析为< code>never。如果ts发现一个交集是有效的，它继续进行，否则返回< code>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 解析为从不，因为 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 不能重叠所有成员，那么该交集的乘积永远不会。因此，它可能不适合作为合并工具：

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

所以请记住，<代码>