数据类型

基本类型

类型	描述	示例代码
number	数字类型，包括整数和浮点数	let age: number = 25;
string	字符串类型	let name: string = "Tom";
boolean	布尔类型，表示 true 或 false	let isStudent: boolean = true;
null	空值	let data: null = null;
undefined	未定义的值	let value: undefined = undefined;
symbol	唯一的符号值（ES6 引入）	const id: symbol = Symbol("id");
bigint	大整数（ES2020 引入）	const bigNumber: bigint = 100n;

引用类型

在 TypeScript 和 JavaScript 中，引用类型是指那些在内存中存储的是对实际数据的引用（或地址），而不是数据本身的类型。引用类型包括对象、数组、函数等。与基本类型（如 number、string、boolean 等）不同，引用类型的变量存储的是对内存中实际数据的引用，因此多个变量可以引用同一个对象，并且对对象的修改会影响所有引用该对象的变量。

以下是一些常见的引用类型：

对象类型：

• {}：对象类型

1

const obj: { name: string; age: number } = { name: 'Alice', age: 30 };

数组类型：

• number[]：数字数组
• Array<number>：数字数组的另一种表示方式

1
2

const arr: number[] = [1, 2, 3];
const arr2: Array<number> = [1, 2, 3];

元组类型：

• [string, number]：固定长度和类型的数组

1

const tuple: [string, number] = ['Alice', 30];

函数类型：

• (param: type) => returnType：函数类型

1

const func: (x: number, y: number) => number = (x, y) => x + y;

接口类型：

• interface：定义对象的结构

1
2
3
4
5

interface Person {
  name: string;
  age: number;
}
const person: Person = { name: 'Alice', age: 30 };

类类型：

• class：定义类

1
2
3
4
5
6
7
8
9

class Person {
  name: string;
  age: number;
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }
}
const person = new Person('Alice', 30);

特殊类型

在 TypeScript 中，有一些特殊类型，它们提供了额外的灵活性和功能。以下是一些常见的特殊类型：

any 类型：

• any 类型表示任意类型，可以赋值为任何类型的值。使用 any 类型会关闭类型检查。

1
2
3

let value: any = 42;
value = 'Hello';
value = true;

unknown 类型：

• unknown 类型表示未知类型，是 any 类型的安全版本。必须进行类型检查后才能对 unknown 类型的值进行操作。

1
2
3
4

let value: unknown = 42;
if (typeof value === 'string') {
  console.log(value.toUpperCase());
}

void 类型：

• void 类型表示没有任何类型，通常用于函数没有返回值的情况。

1
2
3

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

never 类型：

• never 类型表示永不存在的值的类型，通常用于不会正常结束的函数（如抛出错误的函数）或永远不会有返回值的函数。

1
2
3

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

enum 类型：

• enum 类型用于定义一组命名常量。枚举类型可以更好地组织和管理相关的常量值。

数字枚举是默认的枚举类型，每个成员都有一个数值，默认从 0 开始递增。

1
2
3
4
5
6
7
8
9

enum Direction {
  Up,
  Down,
  Left,
  Right
}

let dir: Direction = Direction.Up;
console.log(dir); // 输出: 0

其他类型

联合类型（Union Types）

联合类型表示一个值可以是几种类型之一。使用竖线 (|) 分隔多个类型来定义联合类型。

1
2
3

let value: string | number;
value = 'Hello'; // 合法
value = 42; // 合法

交叉类型（Intersection Types）

交叉类型表示一个值同时是几种类型的组合。使用与号 (&) 分隔多个类型来定义交叉类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

interface Person {
  name: string;
}

interface Employee {
  employeeId: number;
}

type EmployeePerson = Person & Employee;

let employee: EmployeePerson = {
  name: 'Alice',
  employeeId: 1234,
};

索引类型（Index Types）

索引类型允许你通过索引操作符 keyof 和索引签名来操作类型。keyof 操作符用于获取某个类型的所有键，索引签名用于访问类型的属性。

1
2
3
4
5
6
7
8
9
10
11
12
13

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

type PersonKeys = keyof Person; // "name" | "age"

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const person: Person = { name: 'Alice', age: 30 };
const name = getProperty(person, 'name'); // "Alice"

映射类型（Mapped Types）

映射类型允许你基于已有类型创建新的类型。使用 in 关键字和索引签名来定义映射类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

type Person = {
  name: string;
  age: number;
};

// 将所有属性变为可选
type PartialPerson = {
  [P in keyof Person]?: Person[P];
};

// 将所有属性变为只读
type ReadonlyPerson = {
  [P in keyof Person]: Readonly<Person[P]>;
};

条件类型（Conditional Types）

条件类型允许你根据条件来选择类型。使用 extends 关键字来定义条件类型。

1
2
3
4

type IsString<T> = T extends string ? 'yes' : 'no';

type A = IsString<string>; // "yes"
type B = IsString<number>; // "no"

模版字符串类型（Template Literal Types）

模版字符串类型允许你基于字符串字面量类型创建新的字符串类型。使用反引号（`）和 ${} 语法来定义模版字符串类型。

1
2
3
4
5

type World = 'world';
type Greeting = `hello ${World}`; // "hello world"

type Person = 'Alice' | 'Bob';
type GreetingMessage = `Hello, ${Person}!`; // "Hello, Alice!" | "Hello, Bob!"

字面量类型（Literal Types）

字面量类型允许你指定具体的字符串、数字或布尔值作为类型。

1
2
3
4
5

type Direction = 'up' | 'down' | 'left' | 'right';
let move: Direction;
move = 'up'; // OK
move = 'down'; // OK
move = 'go'; // Error