TypeScript 类型断言 关于 “ as “ 语法的各种用法

在 TypeScript 中，as 关键字用于类型断言，允许你将某个值强制转换为你期望的类型。下面是一些使用as关键字将值断言为不同类型的例子：

断言为 Object

let someValue: any = { ... };
let obj = someValue as Object;

断言为 string

let someValue: any = "this is a string";
let str = someValue as string;

断言为 number

let someValue: any = 42;
let num = someValue as number;

断言为 function

let someValue: any = function() { /* ... */ };
let func = someValue as Function;

断言为具体函数类型

let someValue: any = function(a: number, b: number): number { return a + b; };
let func = someValue as (a: number, b: number) => number;

断言为 Event

在处理 DOM 事件时，你可能需要将一个类型为 Event 的参数断言为更具体的事件类型，例如 MouseEvent 或 KeyboardEvent。

document.addEventListener("click", (event) => {
  let mouseEvent = event as MouseEvent;
  console.log(mouseEvent.clientX, mouseEvent.clientY);
});

断言为 boolean

let someValue: any = true;
let bool = someValue as boolean;

断言为 Promise

当你知道某个值是一个 Promise 时，你可以断言其为 Promise 类型，还可以指定 Promise 解析的具体类型。

let someValue: any = fetch('https://api.example.com/data');
let promise = someValue as Promise<any>; // 如果你不确定Promise解析的类型

或者，如果你知道返回的数据类型：

let someValue: any = fetch('https://api.example.com/data');
let promise = someValue as Promise<MyDataType>;

在所有这些情况下，as 关键字告诉 TypeScript 编译器：“我知道我在做什么，我确定这个值是这种类型。” 这不会改变程序的运行时行为，只是影响 TypeScript 在编译时的类型检查。

需要注意的是，类型断言并不会在运行时改变值的实际类型，它只是一种类型层面的指示，用于编译时的类型检查。如果你对值的实际类型做了错误的假设，可能会导致运行时错误。因此，应当在确定类型时使用类型断言，并尽可能避免使用 any 类型，以充分利用 TypeScript 提供的类型安全特性。

在 TypeScript 中，类型断言确实不仅限于基本类型和常见的对象类型，还可以用于更复杂或者不常见的类型。以下是一些可能不那么明显但仍然有用的类型断言用法：

断言为枚举类型

如果你有一个枚举类型，你可以断言一个值为该枚举的成员：

enum Color {
  Red,
  Green,
  Blue
}

let c: any = "Red";
let color = c as Color;

断言为联合类型

有时候你可能需要断言到一个联合类型：

let someValue: any = "hello";
let strOrNum = someValue as string | number;

断言为交叉类型

交叉类型表示将多个类型合并为一个类型：

interface BusinessPartner {
  name: string;
  credit: number;
}

interface Identity {
  id: number;
  name: string;
}

let someValue: any = { id: 1, name: "Company Inc.", credit: 1000 };
let partner = someValue as BusinessPartner & Identity;

断言为自定义类型保护

类型保护允许你定义一个函数，它的返回类型是一个类型谓词，你可以利用这个谓词来断言类型：

function isString(test: any): test is string {
  return typeof test === "string";
}

let someValue: any = "this is a string";

if (isString(someValue)) {
  // 在这个块内，someValue 被断言为 string 类型
}

断言为 null 或 undefined

有时候你可能需要断言一个值不是 null 或 undefined：

let someValue: string | null = "this is a string";
let str = someValue as string; // 确定 someValue 不是 null

断言为实例类型

可以断言一个对象为类的实例：

class MyClass {
  someMethod() {}
}

let someValue: any = new MyClass();
let instance = someValue as MyClass;

断言为索引类型

如果你有一个索引类型（例如，一个对象字面量的键是字符串，值的类型是已知的），你可以这样断言：

let someValue: any = { key1: "value1", key2: "value2" };
let obj: { [key: string]: string } = someValue as { [key: string]: string };

断言为 this 类型

在类的方法中，你可能需要断言 this 的类型来确保类型正确：

class BasicCalculator {
  public constructor(protected value: number = 0) { }
  public currentValue(): number {
    return this.value;
  }
  public add(operand: number): this {
    this.value += operand;
    return this as this;
  }
  // ... 更多方法 ...
}

断言为 never

虽然不常见，但有时你可能需要断言一个值为 never 类型，通常用于错误处理或控制流分析：

function error(message: string): never {
  throw new Error(message);
}

let result = error("Critical error!") as never;

这些例子展示了 TypeScript 类型断言的多样性和强大功能。类型断言的关键是确保你对值的实际类型有准确的了解，并且在使用断言时要非常小心，以避免运行时错误。