返回专栏
· 13 分钟阅读

联合类型与交叉类型


一、什么是联合类型(Union Types)

联合类型表示一个值可以属于多个类型中的任意一种。

假设有两个类型:

type StringType = string;
type NumberType = number;

联合类型可以表示为:

type Value = string | number;

Value 表示该值可以是 string,也可以是 number。

let value: string | number;

value = "hello";
value = 100;

value = true; // 编译错误

其中,| 表示逻辑上的选择关系。

从集合角度理解:

A \cup B

表示属于集合 A 或集合 B 的所有元素。

对于类型系统,可以将联合类型理解为多个类型所允许值的集合并集。

1. 联合类型的核心特征

  • 一个值只需要满足联合类型中的某一个成员类型。
  • 可以表示多种可能的数据结构。
  • 类型检查时,不能直接假设值属于某一个具体成员类型。
  • 需要通过类型缩窄确定当前值的具体类型。
  • 联合类型可以包含两个或更多类型。

例如:

type ID = string | number | bigint;

function findUser(id: ID) {
    console.log(id);
}

findUser 可以接受三种不同类型的 ID。

2. 联合类型与可选类型

联合类型经常用于表示可选值。

type UserName = string | undefined;

表示值可以是字符串,也可以是 undefined。

TypeScript 中还可以使用可选属性:

type User = {
    name: string;
    age?: number;
};

在启用严格空值检查时,可选属性读取结果通常包含 undefined。

需要注意:

  • T | undefined 明确表示类型包含 undefined。
  • property?: T 表示属性可以缺省。
  • 两者在对象属性存在性、赋值检查和精确可选属性配置下并不完全等价。

二、联合类型的类型缩窄(Type Narrowing)

联合类型包含多个可能类型,因此编译器不能在未确定具体成员时,允许调用所有成员类型的方法。

例如:

function printValue(value: string | number) {
    console.log(value.toUpperCase());
}

这段代码无法通过类型检查。

原因是:

  • string 存在 toUpperCase()。
  • number 不存在 toUpperCase()。
  • 编译器无法保证 value 一定是字符串。

需要先进行类型缩窄。

1. 使用 typeof 缩窄

function printValue(value: string | number) {
    if (typeof value === "string") {
        console.log(value.toUpperCase());
    } else {
        console.log(value.toFixed(2));
    }
}

typeof 可以在运行时检查 JavaScript 的基本类型,并帮助 TypeScript 推断分支中的类型。

2. 使用 instanceof 缩窄

class Dog {
    bark() {}
}

class Cat {
    meow() {}
}

function handleAnimal(animal: Dog | Cat) {
    if (animal instanceof Dog) {
        animal.bark();
    } else {
        animal.meow();
    }
}

instanceof 适合检查具有运行时构造函数身份的对象。

需要注意,接口和类型别名在 TypeScript 编译后会被擦除,不能直接作为 instanceof 的右侧操作数。

3. 使用 in 操作符缩窄

type Dog = {
    bark: () => void;
};

type Cat = {
    meow: () => void;
};

function handleAnimal(animal: Dog | Cat) {
    if ("bark" in animal) {
        animal.bark();
    } else {
        animal.meow();
    }
}

in 可以检查对象是否具有某个属性,并参与类型缩窄。

不过,如果多个成员类型都可能具有该属性,缩窄结果可能仍然是联合类型。

4. 使用判别属性(Discriminated Union)

判别联合是 TypeScript 中非常重要的建模方式。

type Success = {
    status: "success";
    data: string;
};

type Failure = {
    status: "failure";
    error: string;
};

type Result = Success | Failure;

通过公共判别属性 status 区分不同成员:

function handleResult(result: Result) {
    if (result.status === "success") {
        console.log(result.data);
    } else {
        console.error(result.error);
    }
}

判别联合的优势:

  • 类型结构明确。
  • 分支处理安全。
  • 非法状态组合更难表达。
  • 适合 API 响应、状态机和业务流程建模。

5. 联合类型缩窄流程

flowchart TD
    A["接收联合类型值"] --> B["分析可能的成员类型"]
    B --> C["执行类型检查"]
    C --> D{"是否确定具体成员"}
    D -->|"是"| E["缩窄为对应类型"]
    D -->|"否"| F["保留联合类型"]
    E --> G["访问该类型支持的操作"]
    F --> H["继续检查或处理公共能力"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style H fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

三、什么是交叉类型(Intersection Types)

交叉类型表示一个值同时满足多个类型的约束。

假设有两个类型:

type Person = {
    name: string;
};

type Employee = {
    employeeId: number;
};

可以通过 & 将它们组合:

type Staff = Person & Employee;

此时 Staff 同时包含两个类型的属性要求:

const staff: Staff = {
    name: "Alice",
    employeeId: 1001
};

如果缺少任意一个必需属性,就无法满足 Staff 的类型要求。

从集合角度理解:

A \cap B

表示同时属于集合 A 和集合 B 的元素。

对于类型系统,交叉类型表示一个值必须同时满足多个类型约束。

1. 交叉类型的核心特征

  • 一个值必须同时满足所有成员类型的要求。
  • 可以组合多个对象类型。
  • 可以扩展已有类型的能力。
  • 可以将多个接口约束合并。
  • 多个类型之间存在冲突时,可能产生难以使用甚至不可构造的类型。

例如:

type Timestamped = {
    createdAt: Date;
};

type Identifiable = {
    id: string;
};

type Entity = Timestamped & Identifiable;

Entity 同时具备:

  • createdAt 属性。
  • id 属性。

交叉类型特别适合组合式类型设计。

2. 交叉类型与接口继承

交叉类型和接口继承都可以组合多个类型的成员,但它们的语义和适用场景不同。

交叉类型:

type Person = {
    name: string;
};

type Employee = {
    employeeId: number;
};

type Staff = Person & Employee;

接口继承:

interface Person {
    name: string;
}

interface Employee {
    employeeId: number;
}

interface Staff extends Person, Employee {}

对比:

维度 交叉类型 接口继承
语法 A & B extends A, B
组合对象类型 支持 支持
组合类型别名 支持 不能直接继承任意联合类型
属性冲突 可能形成复杂交叉结果 声明时通常会检查兼容性
使用方式 类型组合表达式 声明接口层次
适用场景 灵活组合类型 稳定的对象契约

四、交叉类型的类型组合机制

1. 对象属性合并

当两个对象类型的属性不冲突时,交叉类型通常表现为属性要求的组合。

type A = {
    id: number;
};

type B = {
    name: string;
};

type C = A & B;

等价地理解为:

type C = {
    id: number;
    name: string;
};

这里的等价是从属性使用效果上理解,并不意味着编译器一定将交叉类型直接改写为普通对象字面量。

2. 相同属性的交叉

如果两个类型具有相同属性,需要进一步考虑属性类型之间的关系。

type A = {
    value: string | number;
};

type B = {
    value: string;
};

type C = A & B;

这里 value 必须同时满足:

  • string | number
  • string

最终可用的类型相当于:

type C = {
    value: string;
};

因为 string 本身属于 string | number。

可以从类型集合角度理解:

(string \cup number) \cap string = string

3. 不兼容属性的交叉

如果两个属性类型没有共同的可用值,交叉结果可能变成 never。

type A = {
    value: string;
};

type B = {
    value: number;
};

type C = A & B;

此时 value 必须同时是字符串和数字。

对于 TypeScript 的原始类型 string 与 number,不存在同时满足二者的普通值,因此:

type Value = string & number;
// never

在对象类型中,冲突属性可能导致该属性变成 never,而整个对象类型是否进一步归约为 never,还与属性冲突形式及编译器的类型简化规则有关。

例如:

type A = {
    value: string;
};

type B = {
    value: number;
};

type C = A & B;

const data: C = {
    value: "hello" // 编译错误
};

这种冲突在复杂类型组合中很容易成为隐蔽问题。

4. 交叉类型的约束累积

交叉类型不仅可以组合属性,也可以组合函数签名和其他结构约束。

type HasId = {
    id: string;
};

type HasName = {
    name: string;
};

type HasTimestamp = {
    createdAt: Date;
};

type RecordEntity = HasId & HasName & HasTimestamp;

随着交叉类型的组合,类型约束不断累积。

flowchart TD
    A["类型 A:HasId"] --> D["交叉组合"]
    B["类型 B:HasName"] --> D
    C["类型 C:HasTimestamp"] --> D
    D --> E["RecordEntity"]
    E --> F["必须满足全部属性约束"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

五、联合类型与交叉类型的核心区别

联合类型和交叉类型虽然都用于组合类型,但表达的是两种不同的逻辑关系。

假设:

type A = {
    name: string;
};

type B = {
    age: number;
};

联合类型:

type Union = A | B;

表示一个值满足 A 或 B 中的一个类型。

交叉类型:

type Intersection = A & B;

表示一个值同时满足 A 和 B。

对比维度 联合类型 A \| B 交叉类型 A & B
核心语义 满足其中一种 同时满足全部
集合关系 并集 交集
逻辑理解 OR AND
类型要求 至少满足一个成员 必须满足所有成员
典型用途 多种可能状态 多种能力组合
类型缩窄 通常需要 通常不需要区分成员
类型冲突 保留不同可能性 可能收窄为 never

1. 联合类型的结构理解

type A = {
    name: string;
};

type B = {
    age: number;
};

type U = A | B;

一个对象只需要满足其中一个成员类型即可:

const a: U = {
    name: "Alice"
};

const b: U = {
    age: 18
};

const c: U = {
    name: "Alice",
    age: 18
};

需要注意,TypeScript 的结构化类型系统允许额外属性存在于变量中,因此 c 也可以赋值给 U。

对于直接传入对象字面量的情况,过多的额外属性可能触发多余属性检查(Excess Property Checking)。这是一种额外的静态检查机制,不应将它理解为联合类型只允许出现一个成员的属性。

2. 交叉类型的结构理解

type I = A & B;

对象必须同时具备两个类型的属性:

const value: I = {
    name: "Alice",
    age: 18
};

如果缺少任意一个属性,就无法满足交叉类型。

六、联合类型与交叉类型的代数关系

从类型集合角度,可以将联合和交叉理解为类型的并集与交集。

1. 联合的基本规律

A \cup B = B \cup A

联合顺序不影响集合语义。

(A \cup B) \cup C = A \cup (B \cup C)

联合类型满足结合关系。

A \cup A = A

相同类型联合后仍然是原类型。

2. 交叉的基本规律

A \cap B = B \cap A

交叉顺序不影响集合语义。

(A \cap B) \cap C = A \cap (B \cap C)

交叉类型满足结合关系。

A \cap A = A

相同类型交叉后仍然是原类型。

3. 分配律

类型集合的并集与交集满足分配律:

A \cap (B \cup C) = (A \cap B) \cup (A \cap C)
A \cup (B \cap C) = (A \cup B) \cap (A \cup C)

TypeScript 的条件类型也会体现与联合类型相关的分配行为,但需要注意:TypeScript 的类型系统并不是一个完全按照数学集合运算定义的系统。

特别是:

  • any、unknown、never 有特殊规则。
  • 结构化类型兼容不等于简单的集合相等。
  • 条件类型的分配行为具有明确的语法条件。
  • 对象属性冲突可能导致类型被简化为 never。

因此,集合代数适合帮助理解,不应直接替代具体语言的类型规则。

七、never 与 unknown 在联合和交叉中的作用

never 和 unknown 是理解 TypeScript 联合与交叉类型的重要基础。

1. never:底类型

never 表示不可能存在的值类型。

type A = string | never;
type B = string & never;

结果:

type A = string;
type B = never;

对应关系:

A \cup never = A
A \cap never = never

never 常用于:

  • 表示永远不会正常返回的函数。
  • 表示不可能出现的状态。
  • 检查联合类型是否穷尽处理。
  • 条件类型中的过滤和分支计算。

2. unknown:安全的顶类型

unknown 可以表示任意值,但在使用之前必须进行类型检查。

let value: unknown;

value = "hello";
value = 100;

联合:

type A = string | unknown;
// unknown

交叉:

type B = string & unknown;
// string

对应关系: