TypeScript中的类型

在 TypeScript 中，有许多内建的类型，也可以定义自己的类型。以下是一些常见的 TypeScript 类型：

基本类型

1. number: 用于表示数值。

   let age: number = 30;

2. string: 用于表示文本。

   let name: string = "Alice";

3. boolean: 用于表示真或假。

   let isStudent: boolean = true;

复合类型

4. array: 用于表示一个元素列表。

   let numbers: number[] = [1, 2, 3];
   // 或
   let numbers: Array = [1, 2, 3];

5. tuple: 用于表示一个已知元素数量和类型的数组。

   let tupleType: [string, number] = ["hello", 42];

6. enum: 用于定义一组有名的常数。

   enum Colors {
    Red,
    Green,
    Blue,
   }
   let color: Colors = Colors.Green;

7. any: 用于表示任何类型。尽量避免使用它，因为它会关闭 TypeScript 的类型检查。

   let notSure: any = 4;
   notSure = "maybe a string";
   notSure = false;

8. void: 用于表示没有类型，通常用在不返回任何值的函数的返回类型。

   function warnUser(): void {
    console.log("This is a warning message");
   }

9. null and undefined: 它们分别是他们各自类型的唯一值。

   let u: undefined = undefined;
   let n: null = null;

函数和方法类型

10. function: 用于定义函数的类型。

    function add(x: number, y: number): number {
      return x + y;
    }

对象类型和接口

11. object: 用于表示非原始类型。

    let obj: object = {};

12. interface: 用于定义对象的结构。

    interface Person {
      firstName: string;
      lastName: string;
    }

高级类型

13. union: 用于定义一个值可以是几种类型之一。

    let mixedType: number | string = 20;
    mixedType = "hello";

14. intersection: 用于合并多个类型。

    type CombinedType = Type1 & Type2;

15. type alias: 用于给一个类型创建新的名字。

    type Name = string;

16. generics: 用于创建可重用的组件。

    function identity(arg: T): T {
      return arg;
    }

断言和类型守卫

17. type assertions: 允许你覆盖一个变量的类型。

    let someValue: any = "this is a string";
    let strLength: number = (someValue).length;
    // 或
    let strLength: number = (someValue as string).length;

18. type guards: 用于运行时检查一个变量的类型。

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

字面量类型和映射类型等

19. Literal Types: 用于限制变量的值只能是特定的值。

    type Easing = "ease-in" | "ease-out" | "ease-in-out";

20. Mapped Types: 用于从一个类型创建一个新的类型。

    type Readonly = {
      readonly [P in keyof T]: T[P];
    };

以上类型可以用于构建复杂的类型定义，并能够利用 TypeScript 提供的类型安全性。