ts中的类型

在 TypeScript 中，类型是静态类型系统的核心，用于在编译阶段检查代码的正确性。TypeScript 提供了丰富的类型系统，包括基本的原始类型、复合类型、以及用户自定义的类型。以下是对 TypeScript 中各种类型的详细分类和说明：

1. 原始类型（Primitive Types）

原始类型是 TypeScript 中的基本数据类型，它们是不可变的。TypeScript 继承了 JavaScript 的所有原始类型，并添加了一些额外的类型支持。

1.1 number

表示数字，包括整数和浮点数。

let num: number = 42;       // 整数
let pi: number = 3.14;      // 浮点数

1.2 string

表示文本数据，由字符组成的序列。

let greeting: string = "Hello, TypeScript!";  // 字符串

1.3 boolean

表示逻辑实体，只有两个值：true 和 false。

let isReady: boolean = true;

1.4 undefined

表示变量已声明但未初始化，即没有赋予具体的值。

let x: undefined;  // x 的值为 undefined

1.5 null

表示故意赋予变量的空值。

let y: null = null;  // y 的值为 null

1.6 symbol

表示一个唯一的、不可变的数据类型，通常用于对象属性的键。

let mySymbol: symbol = Symbol('mySymbol');

1.7 bigint

表示大于 2^53 - 1 的整数。

let bigNumber: bigint = BigInt(1234567890123456789012345678901234567890n); // BigInt 类型的值后面加 n

1.8 void

表示没有返回值的函数或变量。

function logMessage(message: string): void {
  console.log(message);
}

1.9 never

表示永远不会返回的函数或变量，通常用于错误处理。

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

1.10 unknown

表示一个未知的类型，可以在运行时检查后再使用。

let value: unknown;
value = 42;  // OK
value = "Hello";  // OK

2. 复合类型（Composite Types）

复合类型是由多个值组成的类型，包括数组、元组、对象、枚举等。

2.1 Array

表示一个有序的值的集合，可以包含任意类型的元素。

let numbers: number[] = [1, 2, 3];
let strings: string[] = ["a", "b", "c"];
let mixed: (string | number)[] = [1, "two", 3];

2.2 Tuple

表示一个固定长度的数组，每个位置的类型可以不同。

let tuple: [string, number] = ["Alice", 25];

2.3 Object

表示一个无序的键值对集合。

let person: { name: string; age: number } = { name: "Alice", age: 25 };

2.4 Interface

用于定义对象的结构。

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

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

2.5 Type Alias

用于定义类型别名，可以简化复杂的类型声明。

type Point = { x: number; y: number };

let point: Point = { x: 10, y: 20 };

2.6 Enum

用于定义一组命名的常量。

enum Color { Red, Green, Blue }

let color: Color = Color.Red;

3. 函数类型

函数类型用于定义函数的参数类型和返回值类型。

3.1 函数声明

function add(a: number, b: number): number {
  return a + b;
}

3.2 函数表达式

let add: (a: number, b: number) => number = (a, b) => a + b;

4. 联合类型（Union Types）

联合类型表示一个值可以是几种类型之一。

let value: string | number;
value = "Hello";  // OK
value = 42;       // OK

5. 交叉类型（Intersection Types）

交叉类型表示一个值同时具有多个类型。

type Person = { name: string; age: number };
type Loggable = { log: () => void };

type PersonWithLogging = Person & Loggable;

let personWithLogging: PersonWithLogging = {
  name: "Alice",
  age: 25,
  log() {
    console.log(`Name: ${this.name}, Age: ${this.age}`);
  }
};

6. 类型断言（Type Assertions）

类型断言用于告诉 TypeScript 编译器某个值的类型。

let value: any = "Hello";
let strLength: number = (value as string).length;

7. 类型守卫（Type Guards）

类型守卫用于在运行时检查变量的类型。

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

let value: any = "Hello";

if (isString(value)) {
  console.log(value.toUpperCase()); // OK
}

8. 类型查询（Type Queries）

类型查询用于获取一个类型的类型。

type Box<T> = { value: T };

type BoxType = typeof Box; // BoxType 的类型是 (T) => { value: T }

9. 条件类型（Conditional Types）

条件类型用于根据条件选择不同的类型。

type IsNumber<T> = T extends number ? "Yes" : "No";

type IsNumberResult = IsNumber<42>; // "Yes"
type IsNotNumberResult = IsNumber<string>; // "No"

10. 映射类型（Mapped Types）

映射类型用于基于现有类型生成新的类型。

type OptionsFlags<Type> = {
  [Property in keyof Type]: boolean;
};

type FeatureFlags = { darkMode: () => void; newUserProfile: () => void };

type FeatureOptions = OptionsFlags<FeatureFlags>; // { darkMode: boolean; newUserProfile: boolean }

11. 索引签名（Index Signatures）

索引签名用于定义对象的动态属性。

type StringArray = { [index: number]: string };

let myArray: StringArray = {};
myArray[0] = "Hello";
myArray[1] = "TypeScript";

12. 字面量类型（Literal Types）

字面量类型用于定义具体的值。

type Name = "Alice" | "Bob";

let name: Name = "Alice";  // OK
name = "Bob";             // OK
name = "Charlie";         // Error

13. 类型别名与接口的区别

• 类型别名（type）：

  • 可以用于联合类型、元组等。
  • 可以定义原始类型、联合类型、元组等。
  • 不支持扩展和实现。

  type Point = { x: number; y: number };

• 接口（interface）：

  • 主要用于描述对象的结构。
  • 支持扩展和实现。
  • 可以在运行时检查。

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

总结

TypeScript 提供了丰富的类型系统，包括基本的原始类型、复合类型、函数类型、联合类型、交叉类型、类型断言、类型守卫、类型查询、条件类型和映射类型等。这些类型系统使得 TypeScript 能够在编译阶段进行严格的类型检查，从而减少运行时错误，提高代码的可维护性和可读性。通过合理使用这些类型，你可以编写出更安全、更可靠的代码。