TypeScript基础知识（四）类型断言和类型保护

类型断言（Type Assertion）

类型断言（Type Assertion）是 TypeScript 中的一种语法，它允许我们告诉编译器某个值的具体类型，并相信我们的断言是正确的。类型断言在编译时不会进行类型检查，但它只会影响编译阶段的类型推断，不会影响实际运行时的类型。

概念：
类型断言是一种允许程序员手动指定类型的机制，用于解决编译器无法准确推断出类型的情况。

特点：

1. 类型断言通过使用 as 关键字或尖括号语法（仅限于 JSX）来进行。
2. 类型断言可以用于任何类型，但仅限于兼容的类型之间进行转换。换句话说，不能将一个值断言为不兼容的类型。
3. 类型断言不会改变变量的类型，只是在编译阶段告诉编译器该值的类型。

优点：

1. 类型断言可以应对一些类型推断困难或不准确的情况，从而提供更好的灵活性。
2. 类型断言可以使用一些非类型安全的 API，并告诉编译器我们已经处理了类型相关的问题。

缺点：

1. 类型断言是一种主观判断，如果断言错误可能会导致运行时错误。
2. 过度使用类型断言可能会隐藏真正的类型错误。

应用场景：

1. 在你比编译器更了解某个值的类型时，可以使用类型断言来指定类型。
2. 在使用一些不规范的第三方库或接口时，可以使用类型断言进行类型兼容。
3. 在使用 TypeScript 和 JavaScript 混合编写的项目中，可以使用类型断言来处理类型不一致的情况。

下面是一个简单的代码案例，演示了如何使用类型断言：

let value: number | string = "100";
let length: number = (value as string).length;

console.log(length); // 输出 3

在上面的示例中，我们有一个变量 value，它的类型被定义为 number | string，即可以是数字类型也可以是字符串类型。然而，我们想获取字符串的长度，所以我们使用类型断言 as string 来告诉编译器 value 是一个字符串类型。然后，我们将这个值赋给了另一个变量 length，它的类型是 number，这是因为我们知道 length 是一个数字。最后，我们打印输出了 length 的值，得到了正确的结果。

以下是几个 TypeScript 中使用类型断言（Type Assertion）的代码案例参考：

1. 在函数中使用类型断言：

function printLength(str: string | number) {
  // 使用类型断言将 str 的类型缩小为 string
  if (typeof str === 'string') {
    console.log(str.length); // 可以安全地调用 string 的方法
  } else {
    console.log('Invalid input!');
  }
}

2. 在变量声明中使用类型断言：

let num: unknown = 5;
// 使用类型断言将 unknown 类型断言为 number 类型
let newNum = num as number;
console.log(newNum * 2); // 可以安全地进行数值运算

3. 在对象属性访问中使用类型断言：

interface Person {
  name: string;
  age?: number;
}

let person: Person = { name: 'Tom' };
// 使用类型断言判断属性是否存在并访问
if ((person as Person).age !== undefined) {
  console.log((person as Person).age);
} else {
  console.log('Age information does not exist!');
}

4. 在类型转换中使用类型断言：

let myValue: unknown = 'hello world';
// 使用类型断言将 unknown 类型转换为 string 类型
let myString = myValue as string;
console.log(myString.toUpperCase()); // 可以安全地对 string 进行字符串操作

这些代码案例展示了 TypeScript 中如何使用类型断言来确定变量的类型，从而在特定情况下安全地进行操作。请注意，在使用类型断言时要确保断言的类型是准确的，避免类型错误。

类型保护（Type Guards）

类型保护（Type Guards）是在 TypeScript 中用于判断变量的类型的一种方法。它可以用来缩小变量的类型范围，使得变量在特定的条件下具有更具体的类型。这样可以提供更好的类型安全性，避免在运行时出现不期望的错误。

类型保护的特点：

1. 通过使用类型保护，可以根据条件判断来缩小变量的类型范围，使得变量在不同的分支中具有不同的类型。
2. 类型保护可以在编译时进行类型检查，减少运行时的错误。
3. 类型保护可以提供更具体的类型，使得代码更易于理解和维护。

类型保护的优点：

1. 提供类型安全性：类型保护可以在编译时发现一些类型错误，减少运行时出现的错误。
2. 提高代码可读性和可维护性：通过使用类型保护，可以使代码更具有表达性，提高代码的可读性和可维护性。

类型保护的缺点：

1. 增加代码复杂性：使用类型保护需要在代码中添加一些额外的逻辑判断，增加了代码的复杂性。
2. 有些类型判断可能不准确：类型保护可能会根据一些特定的条件进行类型判断，但这些条件可能并不准确，导致类型保护判断的结果也不准确。

类型保护的应用场景：

1. 参数类型检查：在函数中根据参数的类型执行不同的逻辑。
2. 类型推断：通过类型保护的方式，根据已知信息推断变量的类型。
3. 类型转换：在检查变量的类型之后，可以使用类型断言（Type Assertion）来将变量的类型指定为更具体的类型。

下面是一个使用类型保护和类型断言的简单代码案例：

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

let value: string | number = 'hello';
logValue(value);  // 输出 HELLO

value = 3.1415926;
logValue(value);  // 输出 3.14

在上面的代码中，我们定义了一个 logValue 函数，它接受一个参数 value，该参数的类型是 string 或 number。在函数内部，我们使用 typeof 来判断 value 的类型。如果 value 的类型是 string，我们将其转换为大写字母并输出；如果 value 的类型是 number，我们将其保留两位小数并输出。通过使用类型保护和类型断言，我们可以在不同的分支中处理不同的类型，并获得更好的类型安全性。

下面是几个使用 TypeScript 类型保护的简单代码案例：

1. 使用 typeof 类型保护：

function printLength(value: string | number) {
  if (typeof value === 'string') {
    console.log(value.length);
  } else {
    console.log('Value is not a string');
  }
}

2. 使用 instanceof 类型保护：

class Animal {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
}

class Dog extends Animal {
  breed: string;
  constructor(name: string, breed: string) {
    super(name);
    this.breed = breed;
  }
}

function printAnimalName(animal: Animal) {
  if (animal instanceof Dog) {
    console.log(animal.breed);
  } else {
    console.log(`Unknown animal type: ${animal}`);
  }
}

3. 使用类型断言进行类型保护：

interface Square {
  kind: 'square';
  size: number;
}

interface Circle {
  kind: 'circle';
  radius: number;
}

type Shape = Square | Circle;

function printShapeInfo(shape: Shape) {
  if (shape.kind === 'square') {
    const square = shape as Square;
    console.log(`Square: size = ${square.size}`);
  } else if (shape.kind === 'circle') {
    const circle = shape as Circle;
    console.log(`Circle: radius = ${circle.radius}`);
  }
}

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

interface Car {
  brand: string;
  speed: number;
}

function isFastCar(car: Car): car is Car & { speed: 200 } {
  return car.speed === 200;
}

function printCarSpeed(car: Car) {
  if (isFastCar(car)) {
    console.log(`Fast car: ${car.brand}`);
  } else {
    console.log(`Normal car: ${car.brand}`);
  }
}

这些代码案例展示了不同情况下的类型保护使用方法。