TypeScript 交叉类型：用 & 组合多个类型

交叉类型写作 A & B，描述的是同时是 A 又是 B 的值。对于对象类型，这意味着值拥有两边的每一个属性。用它可以组合已有的类型，而不必把属性重新写一遍。

type Person = { name: string; email: string };
type Employee = { employeeId: number; team: string };

type Staff = Person & Employee; // has all four properties

const ada: Staff = { name: "Ada", email: "ada@example.com", employeeId: 7, team: "compilers" };

function badge(s: Staff): string {
  return `${s.name} (#${s.employeeId}, ${s.team})`;
}

console.log(badge(ada)); // Ada (#7, compilers)

// @ts-expect-error: Type '{ name: string; email: string; employeeId: number; }' is not assignable to type 'Staff'.
const partial: Staff = { name: "Alan", email: "alan@example.com", employeeId: 8 };

第二个对象缺少 team，所以会出现编译错误 TS2322，错误信息的下一行写着 Property 'team' is missing ... but required in type 'Employee'。凡是需要 Person 或 Employee 的地方，都可以传入 Staff 值。

组合对象类型

& 可以任意组合类型别名、接口和内联对象类型，也可以用于泛型类型参数。最后这种情况是它难以替代的地方：一个给传入对象添加属性的函数，可以精确地表达这一点。

function withMeta<T extends object>(obj: T, author: string): T & { author: string; savedAt: string } {
  return { ...obj, author, savedAt: "2024-03-15T10:30:00.000Z" };
}

const note = withMeta({ title: "Draft", words: 120 }, "ada");
// type: { title: string; words: number } & { author: string; savedAt: string }

console.log(note.title, note.words, note.author); // Draft 120 ada
console.log(note.savedAt);                         // 2024-03-15T10:30:00.000Z

调用者既保留了传入对象的确切类型（title、words），又得到了新增的两个属性。interface ... extends 无法表达“不管 T 是什么，再加上这些属性”，因为接口不能继承类型参数。

冲突的属性会变成 never

当两边声明了同一个属性时，这个属性的类型是两者的交叉。如果这两个类型没有共同的值，属性就会变成 never，而编译器在你真正创建值之前一声不吭：

// This does not compile: id cannot be a string and a number at once
type WithStringId = { id: string; name: string };
type WithNumberId = { id: number };

type Account = WithStringId & WithNumberId; // no error on this line

const r: Account = { id: "u1", name: "Ada" };
console.log(r);

index.ts(7,22): error TS2322: Type 'string' is not assignable to type 'never'.

错误指向的是对象，而不是导致问题的类型，所以这类 bug 很难追查。在编辑器里把鼠标悬停在 r.id 上，可以看到它的类型：never。如果冲突的属性是字面量标签，例如 type Shape = { kind: "circle" } & { kind: "square" }，TypeScript 会更进一步，把整个交叉类型化简为 never。此时读取这种值的属性，错误信息会说明原因：Property 'kind' does not exist on type 'never'. The intersection 'Shape' was reduced to 'never' because property 'kind' has conflicting types in some constituents.

interface ... extends 则会在声明处就发现同样的冲突，报错 TS2430。这是两者在实践中的主要区别；interface 与 type 的对比页面把它们放在一起做了比较。

兼容的重叠会收窄属性

如果两个属性类型确实有重叠，结果就是重叠的部分。这很有用，并不是错误：

type Editable = { id: string | number; tags: string[] };
type Stored = { id: string; createdAt: string };

type Doc = Editable & Stored; // id: (string | number) & string, which is string

const doc: Doc = { id: "d1", tags: ["draft"], createdAt: "2024-03-15" };
console.log(doc.id.toUpperCase()); // D1: id is a string, so string methods are allowed

type Letters = "a" | "b" | "c";
type Later = "b" | "c" | "d";
type Both = Letters & Later; // "b" | "c": what the two unions have in common

const shared: Both[] = ["b", "c"];
console.log(shared); // [ 'b', 'c' ]

后半部分展示了 & 对联合类型的作用：它保留两边共有的成员。把类型看作值的集合，这些结果就很好预测了。A | B 是两个集合的并集，A & B 是它们的交集，而空的交集就是 never。

交叉类型与联合类型

这两个名字来自集合论，用在对象属性上时会让人觉得是反过来的：

对象类型的交叉类型之所以拥有更多属性，正是因为它允许的值更少：只有具备全部属性的对象才行。

交叉类型与 extends

组合几个对象类型别名时，& 是惯用写法，没有问题。对于由很多部分构成的类型，或者公开 API 的类型，extends 能更早报错，类型检查的开销也更小。

与基本类型交叉：品牌类型

把基本类型和对象类型交叉不会得到 never：string & { readonly __brand: "UserId" } 是一个带有额外标记的字符串，这个标记只在编译时存在。没有哪个真实的字符串拥有这个属性，而这恰恰是目的所在：只有刻意断言品牌的代码才能创建它，所以普通的 string 或 OrderId 再也不能传给需要 UserId 的地方。这种技巧有专门的页面介绍：品牌类型。