在 TypeScript 中，如果你有一个可能具有多种类型的变量，并希望根据其具体类型进行不同的处理，可以使用类型保护（Type Guards）和类型断言（Type Assertions）。以下是几种常见的方法：

1. 使用 typeof 进行基本类型判断

适用于基本类型（如 number, string, boolean, undefined, object, function）。

let value: string | number;

if (typeof value === 'string') {
  // 处理字符串的情况
  console.log(value.toUpperCase());
} else if (typeof value === 'number') {
  // 处理数字的情况
  console.log(value.toFixed(2));
}

2. 使用 instanceof 进行类实例判断

适用于类实例。

class Dog {
  bark() {
    return 'Woof!';
  }
}

class Cat {
  meow() {
    return 'Meow!';
  }
}

let pet: Dog | Cat;

if (pet instanceof Dog) {
  // 处理 Dog 实例的情况
  console.log(pet.bark());
} else if (pet instanceof Cat) {
  // 处理 Cat 实例的情况
  console.log(pet.meow());
}

3. 使用自定义类型保护函数

通过返回一个布尔值的函数来确定变量的具体类型。

interface Bird {
  fly(): void;
  layEggs(): void;
}

interface Fish {
  swim(): void;
  layEggs(): void;
}

function isFish(pet: Bird | Fish): pet is Fish {
  return (pet as Fish).swim !== undefined;
}

function move(pet: Bird | Fish) {
  if (isFish(pet)) {
    // 处理 Fish 类型的情况
    pet.swim();
  } else {
    // 处理 Bird 类型的情况
    pet.fly();
  }
}

4. 使用字面量类型保护

适用于具有特定属性的对象。

type Square = {
  kind: 'square';
  size: number;
};

type Rectangle = {
  kind: 'rectangle';
  width: number;
  height: number;
};

type Shape = Square | Rectangle;

function area(shape: Shape) {
  switch (shape.kind) {
    case 'square':
      // 处理 Square 类型的情况
      return shape.size * shape.size;
    case 'rectangle':
      // 处理 Rectangle 类型的情况
      return shape.width * shape.height;
  }
}

5. 使用类型断言

在某些情况下，你可以明确知道变量的具体类型，这时可以直接使用类型断言。

let someValue: any = "this is a string";
let strLength: number = (someValue as string).length;
// 或者使用尖括号语法
let strLength2: number = (<string>someValue).length;

总结

• typeof: 适用于基本类型。
• instanceof: 适用于类实例。
• 自定义类型保护函数: 提供更复杂的类型判断逻辑。
• 字面量类型保护: 适用于具有特定属性的对象。
• 类型断言: 在你知道变量的具体类型时使用。