一、什么是联合类型(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 或集合 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 和集合 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 | numberstring
最终可用的类型相当于:
type C = {
value: string;
};
因为 string 本身属于 string | number。
可以从类型集合角度理解:
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. 联合的基本规律
联合顺序不影响集合语义。
联合类型满足结合关系。
相同类型联合后仍然是原类型。
2. 交叉的基本规律
交叉顺序不影响集合语义。
交叉类型满足结合关系。
相同类型交叉后仍然是原类型。
3. 分配律
类型集合的并集与交集满足分配律:
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;
对应关系:
never 常用于:
- 表示永远不会正常返回的函数。
- 表示不可能出现的状态。
- 检查联合类型是否穷尽处理。
- 条件类型中的过滤和分支计算。
2. unknown:安全的顶类型
unknown 可以表示任意值,但在使用之前必须进行类型检查。
let value: unknown;
value = "hello";
value = 100;
联合:
type A = string | unknown;
// unknown
交叉:
type B = string & unknown;
// string
对应关系: