TypeScript 知识总结(基础 + 高级)

举报
lisa_he 发表于 2026/11/19 11:08:09 2026/11/19
【摘要】 TypeScript 知识总结(基础 + 高级)TypeScript 是 JavaScript 的超集,为 JS 添加了静态类型系统。编译后生成纯 JS 代码,可在任何浏览器/Node.js 环境运行。TS 解决了 JS 的核心痛点:类型不安全、重构困难、IDE 提示弱。 第一部分:基础 一、TypeScript 简介 1.1 什么是 TypeScript微软开发的编程语言,2012 年发...

TypeScript 知识总结(基础 + 高级)

TypeScript 是 JavaScript 的超集,为 JS 添加了静态类型系统。编译后生成纯 JS 代码,可在任何浏览器/Node.js 环境运行。TS 解决了 JS 的核心痛点:类型不安全、重构困难、IDE 提示弱。


第一部分:基础

一、TypeScript 简介

1.1 什么是 TypeScript

  • 微软开发的编程语言,2012 年发布
  • JavaScript 的超集——所有合法的 JS 代码都是合法的 TS 代码
  • 添加了静态类型系统,编译时检查类型错误
  • 编译后生成纯 JS,运行时没有类型信息(类型擦除)

1.2 TS vs JS

对比项 TypeScript JavaScript
类型系统 静态类型(编译时检查) 动态类型(运行时才知道)
错误发现 编译时(早) 运行时(晚)
IDE 支持 智能提示、跳转定义、重构 较弱
学习曲线 需要学类型语法 直接写
运行环境 需编译为 JS 直接运行
适合项目 中大型项目 小型项目、脚本

1.3 安装与编译

# 全局安装
npm install -g typescript

# 初始化配置文件
tsc --init

# 编译单个文件
tsc index.ts

# 监听模式(文件变化自动编译)
tsc -w

# 验证版本
tsc -v

1.4 第一个 TS 程序

// index.ts
function greet(name: string): string {
  return `Hello, ${name}!`;
}

const message: string = greet('World');
console.log(message);
tsc index.ts    # 生成 index.js
node index.js   # Hello, World!

二、基础类型

2.1 常用类型一览

// 基本类型
let str: string = 'hello';
let num: number = 42;
let bool: boolean = true;

// 数组
let arr: number[] = [1, 2, 3];
let arr2: Array<number> = [1, 2, 3];
let mixed: (string | number)[] = [1, 'a', 2, 'b'];

// 元组(Tuple)—— 固定长度和类型的数组
let tuple: [string, number] = ['Alice', 25];

// 枚举
enum Color { Red, Green, Blue }
let c: Color = Color.Green;  // 1

enum Direction { Up = 'UP', Down = 'DOWN' }
let d: Direction = Direction.Up;  // 'UP'

2.2 特殊类型

类型 说明 示例
any 任意类型,跳过类型检查 let a: any = 1; a = 'x';
unknown 安全的 any,使用前必须断言 let a: unknown = 1; (a as number).toFixed()
void 函数无返回值 function log(): void {}
never 永不返回(抛异常/死循环) function error(): never { throw new Error(); }
null 空值 let n: null = null;
undefined 未定义 let u: undefined = undefined;

2.3 any vs unknown vs never

// any:放弃类型检查(不推荐)
let a: any = 1;
a.foo();  // 编译通过,运行时报错

// unknown:安全的 any,必须先检查类型才能用
let b: unknown = 'hello';
// b.toUpperCase();  // ❌ 报错
if (typeof b === 'string') {
  b.toUpperCase();   // ✅ 正确
}

// never:不可能到达的类型
function throwError(msg: string): never {
  throw new Error(msg);  // 永远不会正常返回
}

// never 的实际用途:穷尽检查
type Shape = 'circle' | 'square';
function getArea(shape: Shape) {
  switch (shape) {
    case 'circle': return Math.PI;
    case 'square': return 4;
    default:
      const _exhaustive: never = shape;  // 如果漏了某个 case,这里会报错
      break;
  }
}

2.4 字面量类型

// 字符串字面量
let direction: 'up' | 'down' | 'left' | 'right';
direction = 'up';   // ✅
// direction = 'top';  // ❌

// 数字字面量
let dice: 1 | 2 | 3 | 4 | 5 | 6;
dice = 3;  // ✅

// 布尔字面量
let alwaysTrue: true = true;

三、类型注解与推断

3.1 类型注解

手动告诉 TS 变量的类型:

let name: string = 'Alice';
let age: number = 25;
let callback: (x: number) => number = (x) => x * 2;

// 函数参数和返回值
function add(a: number, b: number): number {
  return a + b;
}

3.2 类型推断

TS 会自动推断变量的类型,不需要每次都写注解:

let name = 'Alice';      // 推断为 string
let age = 25;            // 推断为 number
let arr = [1, 2, 3];     // 推断为 number[]

// 函数返回值推断
function add(a: number, b: number) {
  return a + b;          // 推断返回值为 number
}

// 对象推断
const user = {
  name: 'Alice',
  age: 25,
};
// 推断为 { name: string; age: number }

3.3 什么时候需要手动标注

场景 是否需要标注
变量声明时有初始值 ❌ 自动推断
函数参数 ✅ 必须
函数返回值 可选(但推荐标注,便于理解)
变量声明时无初始值 ✅ 必须
复杂类型(联合、交叉) ✅ 推荐
// ✅ 有初始值,不需要标注
let count = 0;

// ❌ 无初始值,必须标注
let count: number;
count = 10;

// ✅ 函数参数必须标注
function greet(name: string) {}

// ✅ 返回值推荐标注
function getUser(): User {
  return { name: 'Alice', age: 25 };
}

四、接口与类型别名

4.1 接口(interface)

interface User {
  name: string;
  age: number;
  email?: string;           // 可选属性
  readonly id: number;      // 只读属性
}

const user: User = {
  id: 1,
  name: 'Alice',
  age: 25,
  // email 可以不写
};
// user.id = 2;  // ❌ 只读属性不能修改

4.2 索引签名

interface StringArray {
  [index: number]: string;  // 数组式访问
}
let arr: StringArray = ['a', 'b', 'c'];

interface Config {
  [key: string]: any;       // 任意字符串键
  name: string;             // 具体属性也必须符合索引签名
}

4.3 接口继承

interface Animal {
  name: string;
}

interface Dog extends Animal {
  bark(): void;
}

const dog: Dog = {
  name: 'Rex',
  bark() { console.log('Woof!'); },
};

4.4 类型别名(type)

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

type ID = string | number;

type Callback = (data: any) => void;

type Point = [number, number];  // 元组

4.5 interface vs type

对比项 interface type
语法 interface X {} type X = {}
对象类型 ✅ ✅
联合类型 ❌ ✅ type A = B | C
交叉类型 ❌(用继承模拟) ✅ type A = B & C
元组 ❌ ✅
基本类型别名 ❌ ✅ type ID = string
声明合并 ✅ 同名接口自动合并 ❌ 重复定义报错
继承 extends & 交叉
推荐 对象/类类型 联合/交叉/工具类型
// 声明合并(只有 interface 支持)
interface Window {
  myCustomProp: string;
}
interface Window {
  myCustomMethod(): void;
}
// 两个同名 interface 自动合并

选择建议:对象形状用 interface,联合/交叉/工具类型用 type。


五、函数类型

5.1 函数声明

// 参数和返回值标注
function add(a: number, b: number): number {
  return a + b;
}

// 可选参数(? 标记,必须在必选参数后面)
function greet(name: string, greeting?: string): string {
  return `${greeting || 'Hello'}, ${name}!`;
}

// 默认值(有默认值的参数自动可选)
function greet2(name: string, greeting: string = 'Hello'): string {
  return `${greeting}, ${name}!`;
}

// 剩余参数
function sum(...numbers: number[]): number {
  return numbers.reduce((a, b) => a + b, 0);
}

5.2 函数类型表达式

// 定义函数类型
type MathFunc = (a: number, b: number) => number;

// 使用
const add: MathFunc = (a, b) => a + b;
const subtract: MathFunc = (a, b) => a - b;

5.3 函数重载

同一个函数名,根据参数类型不同执行不同逻辑:

// 重载签名
function process(input: string): string;
function process(input: number): number;
function process(input: boolean): boolean;

// 实现签名(不对外暴露)
function process(input: string | number | boolean): string | number | boolean {
  if (typeof input === 'string') {
    return input.toUpperCase();
  } else if (typeof input === 'number') {
    return input * 2;
  } else {
    return !input;
  }
}

const r1 = process('hello');  // string,类型推断为 string
const r2 = process(42);       // number,类型推断为 number
const r3 = process(true);     // boolean,类型推断为 boolean

5.4 this 类型

interface Button {
  text: string;
  onClick(this: Button, event: Event): void;
}

const button: Button = {
  text: 'Click',
  onClick(event) {
    console.log(this.text);  // this 被正确推断为 Button
  },
};

六、类

6.1 类的基本语法

class Person {
  // 属性声明
  name: string;
  private age: number;       // 私有
  readonly id: number;       // 只读

  // 构造函数
  constructor(name: string, age: number, id: number) {
    this.name = name;
    this.age = age;
    this.id = id;
  }

  // 方法
  greet(): string {
    return `Hello, I'm ${this.name}`;
  }
}

const p = new Person('Alice', 25, 1);
console.log(p.greet());
// p.age;  // ❌ private 不可外部访问

6.2 参数属性(简写)

class Person {
  constructor(
    public name: string,      // 自动创建 public 属性
    private age: number,      // 自动创建 private 属性
    readonly id: number,      // 自动创建 readonly 属性
  ) {}
}

const p = new Person('Alice', 25, 1);
console.log(p.name);  // ✅ public

6.3 访问修饰符

修饰符 类内 子类 类外
public ✅ ✅ ✅
private ✅ ❌ ❌
protected ✅ ✅ ❌
readonly ✅(读) ✅(读) ✅(读)

6.4 存取器(getter/setter)

class Temperature {
  private _celsius: number = 0;

  get celsius(): number {
    return this._celsius;
  }

  set celsius(value: number) {
    if (value < -273.15) {
      throw new Error('温度不能低于绝对零度');
    }
    this._celsius = value;
  }

  get fahrenheit(): number {
    return this._celsius * 9 / 5 + 32;
  }
}

const temp = new Temperature();
temp.celsius = 25;
console.log(temp.fahrenheit);  // 77

6.5 抽象类

abstract class Animal {
  abstract makeSound(): void;  // 抽象方法,子类必须实现

  move(): void {               // 普通方法
    console.log('Moving...');
  }
}

class Dog extends Animal {
  makeSound(): void {
    console.log('Woof!');
  }
}

// const a = new Animal();  // ❌ 抽象类不能实例化
const dog = new Dog();
dog.makeSound();  // Woof!
dog.move();       // Moving...

6.6 类实现接口

interface Serializable {
  serialize(): string;
}

interface Comparable {
  compareTo(other: this): number;
}

class User implements Serializable, Comparable {
  constructor(public name: string, public age: number) {}

  serialize(): string {
    return JSON.stringify({ name: this.name, age: this.age });
  }

  compareTo(other: User): number {
    return this.age - other.age;
  }
}

七、泛型

7.1 为什么需要泛型

// 没有 泛型:要么用 any(丢失类型),要么写多个函数
function identityAny(arg: any): any {
  return arg;
}
const result = identityAny('hello');  // result 是 any,没有提示

// 有 泛型:保留类型信息
function identity<T>(arg: T): T {
  return arg;
}
const result = identity('hello');     // result 是 string
const result2 = identity(42);         // result2 是 number

7.2 泛型函数

function first<T>(arr: T[]): T {
  return arr[0];
}

first([1, 2, 3]);          // 返回 number
first(['a', 'b', 'c']);    // 返回 string

// 多个泛型参数
function pair<K, V>(key: K, value: V): [K, V] {
  return [key, value];
}
pair('name', 'Alice');     // [string, string]
pair('age', 25);           // [string, number]

7.3 泛型接口

interface Box<T> {
  value: T;
}

const stringBox: Box<string> = { value: 'hello' };
const numberBox: Box<number> = { value: 42 };

// API 响应通用格式
interface ApiResponse<T> {
  code: number;
  message: string;
  data: T;
}

const userResp: ApiResponse<{ name: string; age: number }> = {
  code: 200,
  message: 'success',
  data: { name: 'Alice', age: 25 },
};

7.4 泛型类

class Stack<T> {
  private items: T[] = [];

  push(item: T): void {
    this.items.push(item);
  }

  pop(): T | undefined {
    return this.items.pop();
  }
}

const numStack = new Stack<number>();
numStack.push(1);
numStack.push(2);
const top = numStack.pop();  // number | undefined

7.5 泛型约束

限制泛型必须符合某种结构:

// 约束 T 必须有 length 属性
function getLength<T extends { length: number }>(arg: T): number {
  return arg.length;
}

getLength('hello');    // 5
getLength([1, 2, 3]);  // 3
// getLength(42);      // ❌ number 没有 length
// 使用接口约束
interface HasId {
  id: number;
}

function findById<T extends HasId>(items: T[], id: number): T | undefined {
  return items.find(item => item.id === id);
}

const users = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
findById(users, 1);  // { id: 1, name: 'Alice' }

7.6 keyof 操作符

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

const user = { name: 'Alice', age: 25 };
getProperty(user, 'name');  // string
getProperty(user, 'age');   // number
// getProperty(user, 'email');  // ❌ 'email' 不是 user 的 key

第二部分:高级

八、联合类型与交叉类型

8.1 联合类型(Union)

// 一个值可以是多种类型之一
let id: string | number;
id = 'abc';
id = 123;

// 联合字面量类型
type Status = 'pending' | 'success' | 'error';
let status: Status = 'pending';

8.2 交叉类型(Intersection)

// 多个类型合并为一个
type Person = { name: string };
type Employee = { employeeId: number };
type EmployeePerson = Person & Employee;

const ep: EmployeePerson = {
  name: 'Alice',
  employeeId: 1001,
};

8.3 可辨识联合

// 用一个公共属性区分不同类型
interface Circle {
  kind: 'circle';     // 可辨识属性
  radius: number;
}

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

type Shape = Circle | Square;

function getArea(shape: Shape): number {
  switch (shape.kind) {
    case 'circle':
      return Math.PI * shape.radius ** 2;    // shape 被收窄为 Circle
    case 'square':
      return shape.sideLength ** 2;          // shape 被收窄为 Square
  }
}

8.4 类型守卫

// typeof —— 基本类型判断
function pad(value: string | number): string {
  if (typeof value === 'number') {
    return value.toFixed(2);  // value 被收窄为 number
  }
  return value.toUpperCase(); // value 被收窄为 string
}

// instanceof —— 类实例判断
class Cat { meow(): void {} }
class Dog { bark(): void {} }

function speak(animal: Cat | Dog): void {
  if (animal instanceof Cat) {
    animal.meow();   // 收窄为 Cat
  } else {
    animal.bark();   // 收窄为 Dog
  }
}

// in —— 属性存在判断
interface Fish { swim(): void }
interface Bird { fly(): void }

function move(animal: Fish | Bird): void {
  if ('swim' in animal) {
    animal.swim();   // 收窄为 Fish
  } else {
    animal.fly();    // 收窄为 Bird
  }
}

// 自定义类型谓词
function isError(x: any): x is Error {
  return x instanceof Error;
}

try {
  // ...
} catch (e) {
  if (isError(e)) {
    console.log(e.message);  // e 被收窄为 Error
  }
}

九、类型断言与类型收窄

9.1 类型断言

// 方式 1:as 语法(推荐)
let someValue: unknown = 'hello';
let strLength: number = (someValue as string).length;

// 方式 2:尖括号语法(JSX 中不可用)
let strLength2: number = (<string>someValue).length;

// 断言为更具体的类型
const myCanvas = document.getElementById('main') as HTMLCanvasElement;
const input = document.querySelector('input') as HTMLInputElement;
input.value = 'test';

9.2 非空断言

// ! 告诉 TS "这个值一定不是 null/undefined"
function processValue(value: string | null) {
  // value.toUpperCase();  // ❌ 可能是 null
  value!.toUpperCase();    // ✅ 非空断言
}

// 可选链 + 非空断言
const element = document.querySelector('.btn')!;
element.addEventListener('click', () => {});

警告:非空断言是"我保证不是 null",如果运行时真的是 null,会报错。尽量用可选链代替。

9.3 类型收窄的常见方式

function process(value: string | number | null) {
  // 1. 条件判断
  if (value === null) {
    return;  // value 被收窄为 null
  }
  
  // 2. typeof
  if (typeof value === 'string') {
    value.toUpperCase();  // string
  } else {
    value.toFixed(2);    // number
  }
  
  // 3. 真值检查
  if (value) {
    // value: string | number(排除了 null 和 空字符串和 0)
  }
}

9.4 satisfies 操作符(TS 4.9+)

// 问题:用 as 断言会丢失类型检查
const config = {
  port: 3000,
} as { port: number };
// config.port = 'abc';  // 被错误允许

// 解决:satisfies 保留精确类型,同时验证是否符合目标类型
const config2 = {
  port: 3000,
} satisfies { port: number };
// config2.port 被推断为 3000(字面量类型),更精确

十、映射类型与条件类型

10.1 keyof 操作符

interface User {
  name: string;
  age: number;
  email: string;
}

type UserKeys = keyof User;  // 'name' | 'age' | 'email'

10.2 映射类型

// 把所有属性变成只读
type Readonly<T> = {
  readonly [P in keyof T]: T[P];
};

// 把所有属性变成可选
type Partial<T> = {
  [P in keyof T]?: T[P];
};

// 实际使用
type ReadonlyUser = Readonly<User>;
type PartialUser = Partial<User>;

// 修饰符映射:- 表示移除修饰符
type Mutable<T> = {
  -readonly [P in keyof T]: T[P];  // 移除 readonly
};

10.3 条件类型

// 语法:T extends U ? X : Y
type IsString<T> = T extends string ? 'yes' : 'no';

type A = IsString<string>;   // 'yes'
type B = IsString<number>;   // 'no'
type C = IsString<any>;      // 'yes' | 'no'(分配律)

10.4 infer 关键字

在条件类型中提取类型:

// 提取函数返回值类型
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

type R1 = ReturnType<() => string>;           // string
type R2 = ReturnType<(x: number) => boolean>; // boolean

// 提取 Promise 的值类型
type Awaited<T> = T extends Promise<infer U> ? U : T;

type R3 = Awaited<Promise<number>>;   // number
type R4 = Awaited<Promise<string>>;   // string

// 提取数组元素类型
type ElementOf<T> = T extends (infer E)[] ? E : never;

type R5 = ElementOf<string[]>;   // string
type R6 = ElementOf<number[]>;   // number

// 提取构造函数参数类型
type ConstructorParameters<T> = T extends new (...args: infer P) => any ? P : never;

10.5 条件类型的分配律

// 裸类型参数会分配
type ToArray<T> = T extends any ? T[] : never;

type R = ToArray<string | number>;
// 等价于 ToArray<string> | ToArray<number>
// 结果:string[] | number[]

// 阻止分配:用方括号包裹
type ToArrayNonDist<T> = [T] extends [any] ? T[] : never;

type R2 = ToArrayNonDist<string | number>;
// 结果:(string | number)[]

十一、内置工具类型

11.1 属性操作类

interface User {
  name: string;
  age: number;
  email?: string;
}

// Partial —— 所有属性变可选
type PartialUser = Partial<User>;
// { name?: string; age?: number; email?: string; }

// Required —— 所有属性变必选
type RequiredUser = Required<User>;
// { name: string; age: number; email: string; }

// Readonly —— 所有属性变只读
type ReadonlyUser = Readonly<User>;
// { readonly name: string; readonly age: number; readonly email?: string; }

// Pick —— 选取部分属性
type UserName = Pick<User, 'name' | 'age'>;
// { name: string; age: number; }

// Omit —— 排除部分属性
type UserWithoutAge = Omit<User, 'age'>;
// { name: string; email?: string; }

11.2 类型转换类

// Record —— 构造键值对类型
type UserMap = Record<string, User>;
const users: UserMap = {
  alice: { name: 'Alice', age: 25 },
};

// ReturnType —— 获取函数返回值类型
function getUser() { return { name: 'Alice', age: 25 }; }
type User = ReturnType<typeof getUser>;
// { name: string; age: number; }

// Parameters —— 获取函数参数类型(元组)
function add(a: number, b: string) {}
type AddParams = Parameters<typeof add>;
// [number, string]

// ConstructorParameters —— 构造函数参数类型
// InstanceType —— 获取构造函数实例类型
class Person { constructor(public name: string) {} }
type P = InstanceType<typeof Person>;  // Person

// Awaited —— 递归解包 Promise
type R = Awaited<Promise<Promise<string>>>;  // string

11.3 字符串操作类(TS 4.1+)

// Uppercase / Lowercase
type Upper = Uppercase<'hello'>;      // 'HELLO'
type Lower = Lowercase<'WORLD'>;      // 'world'

// Capitalize / Uncapitalize
type Cap = Capitalize<'hello'>;       // 'Hello'
type Uncap = Uncapitalize<'Hello'>;   // 'hello'

11.4 工具类型速查表

工具类型 作用
Partial<T> 所有属性可选
Required<T> 所有属性必选
Readonly<T> 所有属性只读
Pick<T, K> 选取 K 指定的属性
Omit<T, K> 排除 K 指定的属性
Record<K, V> 构造 { K: V } 键值对
ReturnType<F> 函数返回值类型
Parameters<F> 函数参数类型(元组)
Awaited<P> 解包 Promise
InstanceType<C> 构造函数实例类型
NonNullable<T> 排除 null 和 undefined
keyof T 获取所有键的联合类型
typeof X 获取变量的类型

十二、自定义工具类型

实战中常用的自定义类型工具:

// 1. 获取对象某个属性的类型
type PropType<T, K extends keyof T> = T[K];

interface User { name: string; age: number; }
type NameType = PropType<User, 'name'>;  // string

// 2. 将指定键变为可选
type OptionalKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

type OptionalAge = OptionalKeys<User, 'age'>;
// { name: string; age?: number; }

// 3. 将指定键变为必选
type RequiredKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;

// 4. 深层 Partial
type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};

interface Config {
  server: { host: string; port: number };
  db: { url: string; timeout: number };
}
type DeepPartialConfig = DeepPartial<Config>;
// 所有层级属性都变可选

// 5. 深层 Readonly
type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
};

// 6. 获取函数的所有重载
type Overloads<T> = T extends {
  (...args: infer A): any;
  (...args: infer B): any;
} ? A | B : T;

// 7. 联合类型转交叉类型
type UnionToIntersection<U> = 
  (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;

// 8. 排除 null 和 undefined 的简写
type NonNull<T> = NonNullable<T>;

// 9. 获取 Promise 链的最终类型
type UnwrapPromise<T> = T extends Promise<infer U> ? UnwrapPromise<U> : T;

// 10. 严格的对象类型(不允许多余属性)
type Strict<T> = {
  [P in keyof T]: T[P];
} & {
  [P in Exclude<keyof any, keyof T>]: never;
};

十三、装饰器

13.1 类装饰器

// 类装饰器:接收构造函数,返回新的构造函数
function Logged<T extends { new(...args: any[]): {} }>(constructor: T) {
  return class extends constructor {
    created_at = new Date().toISOString();
  };
}

@Logged
class User {
  constructor(public name: string) {}
}

const user = new User('Alice');
console.log((user as any).created_at);  // 2024-01-01T00:00:00.000Z

13.2 方法装饰器

// 方法装饰器:接收 (target, propertyKey, descriptor)
function Log(target: any, key: string, desc: PropertyDescriptor) {
  const original = desc.value;
  desc.value = function(...args: any[]) {
    console.log(`调用 ${key},参数: ${args}`);
    const result = original.apply(this, args);
    console.log(`返回: ${result}`);
    return result;
  };
}

class Calculator {
  @Log
  add(a: number, b: number): number {
    return a + b;
  }
}

new Calculator().add(1, 2);
// 调用 add,参数: 1,2
// 返回: 3

13.3 装饰器工厂

// 工厂函数:返回装饰器,可以传参
function Route(path: string) {
  return function (target: any, key: string, desc: PropertyDescriptor) {
    // 把路由信息存到元数据
    Reflect.defineMetadata('path', path, target, key);
  };
}

class UserController {
  @Route('/users/:id')
  getUser() {}
  
  @Route('/users')
  getUsers() {}
}

13.4 属性装饰器与参数装饰器

// 属性装饰器
function Column(name: string) {
  return function (target: any, propertyKey: string) {
    // 标记数据库列名
    Reflect.defineMetadata('column', name, target, propertyKey);
  };
}

// 参数装饰器
function Inject(token: string) {
  return function (target: any, key: string, index: number) {
    Reflect.defineMetadata('inject', token, target, key, index);
  };
}

class User {
  @Column('user_name')
  name: string;
  
  constructor(@Inject('DB') db: any) {}
}

注意:装饰器是实验性特性,需要在 tsconfig 中启用 "experimentalDecorators": true。


十四、模块与声明文件

14.1 模块导出导入

// math.ts
export function add(a: number, b: number): number {
  return a + b;
}

export const PI = 3.14159;

// 默认导出(一个模块只能有一个)
export default function multiply(a: number, b: number): number {
  return a * b;
}

// main.ts
import multiply, { add, PI } from './math';
import * as Math from './math';

// 类型导出
export interface User { name: string; }
export type ID = string | number;

14.2 声明文件(.d.ts)

为 JS 库提供类型声明:

// express.d.ts —— 为没有类型的 JS 库补声明
declare module 'express' {
  interface Request {
    user?: { id: number; name: string };
  }
  
  interface Response {
    json(data: any): void;
  }
  
  const express: () => any;
  export default express;
}

// 全局变量声明
declare const APP_VERSION: string;
declare const API_BASE_URL: string;

// 全局函数
declare function gtag(...args: any[]): void;

14.3 三斜线指令

// 引用其他声明文件(现代项目用 import 代替)
/// <reference types="node" />
/// <reference path="./custom.d.ts" />

14.4 命名空间(namespace)

// 早期 TS 的模块化方案,现代项目推荐用 ES Module
namespace Utils {
  export function formatDate(date: Date): string {
    return date.toISOString();
  }
  
  export const VERSION = '1.0.0';
}

Utils.formatDate(new Date());

十五、tsconfig.json 配置

15.1 常用配置

{
  "compilerOptions": {
    /* 基础 */
    "target": "ES2020",              // 编译目标 JS 版本
    "module": "commonjs",            // 模块系统
    "lib": ["ES2020", "DOM"],        // 可用的 API(DOM 表示浏览器 API)
    "outDir": "./dist",              // 输出目录
    "rootDir": "./src",              // 源码目录
    
    /* 严格检查 */
    "strict": true,                  // 开启所有严格检查(推荐)
    "noImplicitAny": true,           // 禁止隐式 any
    "strictNullChecks": true,        // null/undefined 检查
    "strictFunctionTypes": true,     // 函数类型严格检查
    "noUnusedLocals": true,          // 未使用的变量报错
    "noUnusedParameters": true,      // 未使用的参数报错
    "noImplicitReturns": true,       // 函数所有路径必须返回
    
    /* 模块解析 */
    "moduleResolution": "node",      // 模块解析策略
    "esModuleInterop": true,         // 允许 import express from 'express'
    "allowSyntheticDefaultImports": true,
    "resolveJsonModule": true,       // 允许 import json
    
    /* 路径别名 */
    "baseUrl": ".",                  // 路径解析基准
    "paths": {
      "@/*": ["src/*"],              // @/xxx → src/xxx
      "@components/*": ["src/components/*"]
    },
    
    /* 实验性 */
    "experimentalDecorators": true,   // 装饰器
    "emitDecoratorMetadata": true,    // 装饰器元数据
    
    /* Source Map */
    "sourceMap": true,                // 生成 source map
    
    /* 跳过类型检查 */
    "skipLibCheck": true,             // 跳过 .d.ts 检查(加速)
    "forceConsistentCasingInFileNames": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

15.2 strict 模式包含的检查

选项 说明
strictNullChecks null/undefined 不能赋值给其他类型
noImplicitAny 禁止隐式 any
strictFunctionTypes 函数参数双向检查 → 逆变检查
strictBindCallApply bind/call/apply 严格类型
strictPropertyInitialization 类属性必须初始化
noImplicitThis this 必须有明确类型
alwaysStrict 编译输出加 ‘use strict’

十六、常见面试题

Q1:any 和 unknown 的区别?

  • any:放弃类型检查,可以任意操作
  • unknown:安全的 any,使用前必须先检查类型或断言
  • 推荐:尽量用 unknown 代替 any

Q2:interface 和 type 的区别?

  • interface 只能描述对象类型,type 可以描述任何类型
  • interface 支持声明合并,type 不支持
  • interface 用 extends 继承,type 用 & 交叉
  • 对象形状优先用 interface,联合/交叉/工具类型用 type

Q3:never 类型有什么用?

  • 表示永远不会出现的类型
  • 用于穷尽检查:switch 的 default 分支赋值给 never,漏写 case 会报错
  • 用于过滤:Exclude<T, never> 会移除 never

Q4:什么是泛型?为什么要用?

  • 泛型是参数化类型,让类型像变量一样传递
  • 作用:复用代码同时保留类型安全
  • 示例:function identity<T>(arg: T): T

Q5:keyof 和 typeof 的区别?

  • keyof T:获取类型 T 的所有键的联合类型
  • typeof x:获取变量 x 的类型
const config = { port: 3000 };
type Config = typeof config;          // { port: number }
type Keys = keyof Config;             // 'port'

Q6:什么是类型守卫?

  • 一种运行时检查,TS 据此收窄类型
  • typeof、instanceof、in、自定义类型谓词(x is T)

Q7:as 和 satisfies 的区别?

  • as:类型断言,改变类型但不检查
  • satisfies:验证是否符合目标类型,同时保留原始精确类型

Q8:什么是条件类型的分配律?

  • 裸类型参数在条件类型中会分配
  • T extends U ? X : Y 中 T 是联合类型时,会分别判断每个成员
  • 用 [T] extends [U] 阻止分配

Q9:Partial<T> 的实现原理?

type Partial<T> = {
  [P in keyof T]?: T[P];
};
  • keyof T 获取所有键
  • in 遍历每个键
  • ? 把每个属性变可选

Q10:infer 关键字的作用?

  • 在条件类型中提取类型变量
  • 只能在 extends 条件类型的右侧使用
  • 示例:T extends Promise<infer R> ? R : T

Q11:什么是声明文件?

  • .d.ts 文件,为 JS 代码提供类型信息
  • 不包含实现代码,只有类型声明
  • declare module 'xxx' 为第三方库补充类型

Q12:枚举的潜在问题?

  • 数字枚举会生成反向映射代码,增加体积
  • const enum 会被内联,不生成额外代码
  • 字符串枚举没有反向映射,更安全

Q13:什么是结构类型系统?

  • TS 采用结构类型(鸭子类型):只要结构匹配就是同一类型
  • 与名义类型(Java/C#)不同,不关心类型名称
interface Point { x: number; y: number }
interface Coordinate { x: number; y: number }

const p: Point = { x: 1, y: 2 };     // ✅
const c: Coordinate = p;              // ✅ 结构相同就行

Q14:abstract 和 interface 的区别?

  • abstract class 可以有实现代码,interface 不能
  • abstract class 用 extends,interface 用 implements
  • 一个类只能继承一个抽象类,但可以实现多个接口

Q15:如何在运行时获取 TS 类型?

  • 不能。TS 类型在编译后会被擦除(类型擦除)
  • 运行时只有 JS,没有类型信息
  • 如果需要运行时验证,用 class-validator、zod 等库

十七、最佳实践

  1. 开启 strict 模式:"strict": true,尽早发现类型问题
  2. 禁止 any:用 unknown 代替,或定义明确的类型
  3. 优先用 interface:对象形状用 interface,联合/交叉用 type
  4. 善用工具类型:Partial、Pick、Omit 减少重复定义
  5. 函数返回值标注:便于理解,也便于 IDE 提示
  6. 用 unknown 处理外部数据:API 响应、用户输入先当 unknown,再验证
  7. 路径别名:@/ 代替 ../../../,配置 paths
  8. 避免类型断言滥用:as 是告诉编译器"我比你懂",用错了会掩盖 bug
  9. 用 satisfies 代替 as(TS 4.9+):既验证类型又保留精确推断
  10. 运行时验证用专门库:zod、class-validator、joi,不要只用 TS 类型

总结

TypeScript 的核心可以归纳为两层:

  • 基础层:类型注解 + 接口 + 泛型 —— 日常编码 80% 的场景
  • 高级层:条件类型 + 映射类型 + infer + 工具类型 —— 写类型工具和库时用

掌握基础层就能写出类型安全的业务代码;掌握高级层才能写出可复用的类型工具,理解框架源码中的类型魔法。

TypeScript 的本质是在编译时捕获错误——越早发现问题,修复成本越低。
类型系统不是束缚,而是和编译器的对话:你告诉它你的意图,它帮你检查是否符合。

【声明】本内容来自华为云开发者社区博主,不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0)

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。