联合类型的逻辑或关系与类型保护

news2025/5/14 3:40:08

在 TypeScript 中，联合类型（Union Types）是一种强大的类型工具，它允许一个变量可以是几种不同类型中的一种。联合类型通过逻辑“或”关系（|）连接多个类型。这种类型的灵活性使得我们能够处理多样化的数据输入和返回类型。然而，由于联合类型的变量在不同的使用场景中可能是不同的类型，我们需要采用类型保护（Type Guards）来确保代码的类型安全。

本文将深入探讨联合类型的逻辑“或”关系以及如何使用类型保护来有效地处理联合类型。

1. 联合类型的逻辑或关系

联合类型通过逻辑“或”关系（|）将多个类型组合在一起。例如，当你定义一个变量时，你希望它可以是字符串或数字，那么可以使用联合类型来定义

type StringOrNumber = string | number;

let value: StringOrNumber;
value = "Hello, TypeScript";  // 合法
value = 42;                   // 合法
value = true;                 // 错误，布尔类型不是联合类型的一部分

在上述代码中，value 可以是字符串 (string) 或数字 (number) 类型。联合类型表示的“或”关系意味着变量的值可以是多种类型之一。你可以使用联合类型来表示很多类似的情形，例如：

一个输入框的值可以是字符串或数字。
一个 API 响应可能返回成功（字符串）或错误（数字）代码。

2. 联合类型和类型保护

虽然联合类型非常灵活，但它们的多样性也带来了挑战，特别是在运行时如何根据实际类型做出正确的处理。为了保证代码的安全性和正确性，我们需要使用类型保护（Type Guards）来判断一个变量的具体类型。类型保护帮助 TypeScript 在特定的代码块中“细化”类型，从而提高类型推断的准确性。

3. 类型保护的常见方法

3.1 使用 `typeof` 进行类型保护

typeof 是 TypeScript 提供的一个关键字，用于检查一个变量的基本类型。在联合类型中，我们可以通过 typeof 来判断变量的实际类型，从而进行相应的处理。

type StringOrNumber = string | number;

function handleValue(value: StringOrNumber) {
  if (typeof value === "string") {
    // 类型被细化为 string
    console.log(`It's a string: ${value}`);
  } else {
    // 类型被细化为 number
    console.log(`It's a number: ${value}`);
  }
}

handleValue("Hello, World!");  // 输出: It's a string: Hello, World!
handleValue(123);              // 输出: It's a number: 123

在上面的例子中，我们通过 typeof value === "string" 来判断 value 是否为字符串类型。如果是，则 value 的类型会被 TypeScript 自动细化为 string，此时我们可以安全地使用字符串相关的方法和属性。如果不是字符串，则可以推断它是数字类型，从而进行数字处理。

3.2 使用 `instanceof` 进行类型保护

instanceof 是另一个常见的类型保护工具，通常用于检查一个对象是否为某个类的实例。当联合类型中包含类类型时，instanceof 可以帮助我们区分不同的类实例。

class Dog {
  bark() {
    console.log("Woof!");
  }
}

class Cat {
  meow() {
    console.log("Meow!");
  }
}

type Animal = Dog | Cat;

function makeNoise(animal: Animal) {
  if (animal instanceof Dog) {
    animal.bark();  // 类型被细化为 Dog
  } else {
    animal.meow();  // 类型被细化为 Cat
  }
}

const dog = new Dog();
const cat = new Cat();

makeNoise(dog);  // 输出: Woof!
makeNoise(cat);  // 输出: Meow!

在这个例子中，animal instanceof Dog 和 animal instanceof Cat 用来判断 animal 是 Dog 还是 Cat 的实例。根据不同的类型，TypeScript 会自动细化变量的类型，使我们能够安全地调用特定类的方法。

3.3 自定义类型保护

除了 typeof 和 instanceof，你还可以定义自己的类型保护函数。自定义类型保护通过返回一个布尔值，并且在返回 true 时使用 is 关键字来缩小类型范围。

type StringOrNumber = string | number;

function isString(value: StringOrNumber): value is string {
  return typeof value === "string";
}

function printValue(value: StringOrNumber) {
  if (isString(value)) {
    console.log(`String: ${value}`);
  } else {
    console.log(`Number: ${value}`);
  }
}

printValue("Hello");  // 输出: String: Hello
printValue(123);      // 输出: Number: 123

在这个例子中，isString 是一个自定义的类型保护函数。当 isString(value) 返回 true 时，TypeScript 会知道 value 必定是 string 类型，因此后续代码中对 value 的使用将只限于字符串类型的操作。

4. 联合类型的复杂场景

联合类型常常与其他类型（如交叉类型、数组类型等）结合使用，构建更为复杂的数据结构。我们同样可以在这些复杂类型中使用类型保护。

4.1 联合类型与交叉类型的结合

type A = { name: string };
type B = { age: number };
type C = A & B;  // C 是 A 和 B 的交叉类型

type Person = C | string;  // Person 既可以是 C 类型，也可以是 string 类型

function describe(person: Person) {
  if (typeof person === "string") {
    console.log(`It's a string: ${person}`);
  } else {
    console.log(`Name: ${person.name}, Age: ${person.age}`);
  }
}

describe("John Doe");  // 输出: It's a string: John Doe
describe({ name: "Jane", age: 30 });  // 输出: Name: Jane, Age: 30

在这个例子中，Person 类型是一个联合类型，它可以是一个字符串，也可以是一个包含 name 和 age 属性的对象。通过类型保护，我们能够安全地处理这两种类型。