TypeScript 检查变量是否属于自定义类型

在本文中，我们将介绍如何使用 TypeScript 检查变量是否属于自定义类型。

自定义类型

在 TypeScript 中，我们可以使用接口（interface）或类型别名（type alias）来定义自定义类型。接口是一种抽象的定义，描述了对象的结构和行为，而类型别名则允许我们给类型取一个新的名字，它可以代表任何类型。下面是一个例子：

// 使用接口定义一个自定义类型
interface Person {
  name: string;
  age: number;
}

// 使用类型别名定义一个自定义类型
type Point = {
  x: number;
  y: number;
};

检查变量类型

要检查变量是否属于自定义类型，我们可以使用类型断言（type assertion）或类型保护（type guarding）。

类型断言（Type Assertion）

类型断言是一种在编译时告诉 TypeScript 变量的真实类型的方式。通过使用尖括号<类型>或as 类型的语法，我们可以将一个变量指定为特定的类型。如果变量符合指定的类型，TypeScript 将认为它是该类型的实例。例如：

let person = {
  name: "Alice",
  age: 30
};

// 使用类型断言将 person 指定为 Person 类型
let isPerson = <Person>person;

console.log(isPerson.name); // Alice
console.log(isPerson.age); // 30

类型保护（Type Guarding）

类型保护是一种在运行时检查变量类型的方式。TypeScript 提供了几种类型保护的方法，如类型判断、类型谓词和类型守卫。下面是常见的类型保护方法：

typeof 类型判断

使用 typeof 运算符可以用来判断变量的类型，比如 typeof x === "string" 可以用来判断变量 x 是否为字符串类型。例如：

function doSomething(x: string | number) {
  if (typeof x === "string") {
    console.log("x is a string"); // x 是一个字符串
    console.log(x.length); // 可以访问字符串的属性和方法
  } else {
    console.log("x is a number"); // x 是一个数字
    console.log(x.toFixed(2)); // 可以访问数字的属性和方法
  }
}

doSomething("hello"); // x is a string
doSomething(123); // x is a number

instanceof 类型谓词

使用 instanceof 关键字可以用来检查对象的类型。它检查对象是否属于指定的构造函数。例如：

class Car {
  brand: string;

  constructor(brand: string) {
    this.brand = brand;
  }

  start() {
    console.log(`{this.brand} is starting...`); // 正在启动汽车
  }
}

class Bike {
  type: string;

  constructor(type: string) {
    this.type = type;
  }

  ride() {
    console.log(`Riding a{this.type} bike...`); // 骑行自行车
  }
}

function doSomething(vehicle: Car | Bike) {
  if (vehicle instanceof Car) {
    vehicle.start(); // 调用 Car 类的方法
  } else {
    vehicle.ride(); // 调用 Bike 类的方法
  }
}

let myCar = new Car("BMW");
let myBike = new Bike("Mountain");

doSomething(myCar); // BMW is starting...
doSomething(myBike); // Riding a Mountain bike...

自定义类型守卫

我们可以使用自定义类型守卫来进一步细化对变量类型的判断。类型守卫是一个使用 x is Type 语法的函数，它返回一个布尔值来指示变量的类型。例如：

interface Cat {
  name: string;
  meow(): void;
}

interface Dog {
  name: string;
  bark(): void;
}

function isCat(animal: Cat | Dog): animal is Cat {
  return "meow" in animal;
}

function doSomething(animal: Cat | Dog) {
  if (isCat(animal)) {
    animal.meow(); // 调用 Cat 接口的方法
  } else {
    animal.bark(); // 调用 Dog 接口的方法
  }
}

let cat: Cat = { name: "Tom", meow() { console.log("Meow!"); } };
let dog: Dog = { name: "Spike", bark() { console.log("Woof!"); } };

doSomething(cat); // Meow!
doSomething(dog); // Woof!

示例应用

现在让我们看一个示例应用，演示如何在 TypeScript 中检查变量是否属于自定义类型。

假设我们有一个函数，接收一个参数 animal，它可以是 Cat 或 Dog 类型的实例。我们希望根据 animal 的类型，分别调用 meow 或 bark 方法。我们可以使用类型保护来实现：

interface Cat {
  name: string;
  meow(): void;
}

interface Dog {
  name: string;
  bark(): void;
}

function doSomething(animal: Cat | Dog) {
  if ("meow" in animal) {
    animal.meow(); // 调用 Cat 接口的方法
  } else {
    animal.bark(); // 调用 Dog 接口的方法
  }
}

let cat: Cat = { name: "Tom", meow() { console.log("Meow!"); } };
let dog: Dog = { name: "Spike", bark() { console.log("Woof!"); } };

doSomething(cat); // Meow!
doSomething(dog); // Woof!