The Concise TypeScript Book:基于开源仓库的 TypeScript 7 全面实战指南

原创2026-09-23 17:47:001,733 阅读
文章标签:文档教程

The Concise TypeScript Book:基于开源仓库的 TypeScript 7 全面实战指南

《The Concise TypeScript Book》是一本免费开源的 TypeScript 学习手册,本仓库 README-cs_CZ.md 保存了其捷克语完整版本(共 62 个章节、约 5200 行正文),并在 website/src/content/docs/cs-cz/book 中按章节拆分供在线网站渲染。本文以该文档为主体,结合仓库中的网站源码与构建脚本,系统讲解 TypeScript 的核心概念、tsconfig 配置、类型系统原理与实战技巧,帮助你从入门到进阶完整掌握 TypeScript 7 的高效开发方法。

一、书籍与项目概览

1.1 书籍定位与特色

The Concise TypeScript Book 提供完整而简洁的 TypeScript 语言能力总览:从强大的类型系统到高级特性,覆盖 TypeScript 最新版本(本文档对应的版本为 TypeScript 7.0)。无论你是初学者还是资深开发者,都可以将其作为系统学习与日常查阅的手册。

本书完全免费、开放源码,且定期更新。仓库中除英文原版 README.md 外,还提供了捷克语(README-cs_CZ.md)、中文(README-zh_CN.md)、日语(README-ja_JP.md)等 20 余种语言的翻译版本。

1.2 Plus Edition(付费增强版)

除开源版本外,项目还提供 The Concise TypeScript Book Plus Edition: React and Real-World Patterns for TypeScript 7,包含:

  • 针对 TypeScript 7 更新:最新语言特性与改进总览;
  • TypeScript + React:组件、props、hooks、事件、children、refs 及常见 React 模式的类型化实战建议;
  • 真实项目配方:针对开发与维护 TypeScript 应用时的实际问题给出目标明确的示例。

Plus Edition 的落地代码位于仓库的 website/src/components(如 PlusEditionLanding.astro、PlusEditionSidebarCard.astro 等页面组件)与 website/src/data/plusEdition.ts 数据文件,可在此查看其推广页面的实际实现结构。

1.3 翻译、下载与在线阅读

  • 多语言翻译:本书已翻译为英语、保加利亚语、德语、法语、印尼语、意大利语、日语、韩语、波兰语、葡萄牙语(巴西)、瑞典语、土耳其语、越南语、中文、西班牙语、泰语、俄语、阿拉伯语、捷克语等。每种语言在 website/src/config/locales.ts 中都有对应配置,例如 cs-cz 的 label: 'Čeština'、lang: 'cs-CZ'。
  • EPUB/PDF 下载:downloads/ 目录提供了各语言的 EPUB 与 PDF 文件,例如 typescript-book-cs_CZ.epub、typescript-book-zh_CN.pdf 等。
  • 在线版本:网站基于 Astro + Starlight 构建,内容源为 website/src/content/docs,捷克语章节存放在 website/src/content/docs/cs-cz/book(62 个 markdown 文件,与 README 章节一一对应);同时通过 website/src/lib/llms.ts 与 website/src/pages/llms.txt.ts 生成为 LLM 优化的 llms.txt 索引,便于搜索引擎与 AI Agent 检索引用。

二、TypeScript 入门:是什么与为什么

2.1 什么是 TypeScript

TypeScript 是强类型编程语言,以 JavaScript 为基础。它由 Anders Hejlsberg 于 2012 年设计,现由 Microsoft 作为开源项目开发维护。

  • TypeScript 编译为 JavaScript,可在任何 JavaScript 运行时中运行(浏览器、Node.js 等);
  • 支持函数式、泛型、命令式、面向对象等多种编程范式;
  • 属于编译(转译)语言,运行前先转换为 JavaScript。

2.2 为什么选择 TypeScript

强类型语言允许开发者在数据类型定义中指定约束与行为,从而在程序运行前防止常见编程错误与特定种类的运行时错误,这对大型应用尤其有价值。主要优势:

  • 静态类型(可选强类型);
  • 类型推断;
  • 可访问 ES6/ES7 特性;
  • 跨平台、跨浏览器兼容;
  • 支持 IntelliSense 等工具。

2.3 TypeScript 与 JavaScript 的关系

  • TypeScript 写入 .ts / .tsx 文件,JavaScript 写入 .js / .jsx;.tsx / .jsx 可包含 React 使用的 JSX 语法扩展;
  • TypeScript 是 JavaScript(ECMAScript 2015)的类型化超集:所有 JS 代码都是合法 TS 代码,反之不一定。

例如,纯 JS 函数只需改扩展名为 .ts 即可使用:

const sum = (a, b) => a + b;

而带类型注解的版本必须经过编译才能在 JS 运行时中执行:

const sum = (a: number, b: number): number => a + b;

TypeScript 即使没有显式注解,也能通过类型推断捕获问题:

const items = [{ x: 1 }, { x: 2 }];
const result = items.filter(item => item.y);

编译时报错:

Property 'y' does not exist on type '{ x: number; }'.

类型系统在很大程度上模拟 JavaScript 的运行时行为,例如 + 既可做字符串拼接也可做数字相加:

const result = '1' + 1; // Result is of type string

而对异常用法(如 1 + true)TypeScript 会报错:

Operator '+' cannot be applied to types 'number' and 'boolean'.

2.4 代码生成:类型在运行时被擦除

编译器有两个独立任务:类型检查和编译为 JavaScript。类型不影响运行时行为,因为它们在编译时被完全移除。因此:

  • 即使存在类型错误,TypeScript 仍可生成 JavaScript;
  • 类型无法在运行时被检查,instanceof 不能作用于 interface。

运行时判别类型,常用的做法是标签联合(tagged union):

interface Dog {
    kind: 'dog'; // Tagged union
    bark: () => void;
}
interface Cat {
    kind: 'cat'; // Tagged union
    meow: () => void;
}
type Animal = Dog | Cat;

const makeNoise = (animal: Animal) => {
    if (animal.kind === 'dog') {
        animal.bark();
    } else {
        animal.meow();
    }
};

而 class 作为 JS 关键字,既可作类型也可作运行时值,instanceof 可用于类实例判别。TypeScript 对运行时性能没有影响(类型全部被擦除),但会带来一定的构建开销。

2.5 现代 JavaScript 即刻可用(Downleveling)

TypeScript 可编译到 ECMAScript 3(1999)以来的任何 JS 版本,即将最新特性转换为旧版本(downleveling),同时保持与旧运行时最大兼容。可放心使用的新特性包括:ES 模块、class、let/const、for-of、箭头函数、解构赋值、属性简写/计算属性名、默认参数等。注意转译为旧版本时可能产生性能开销。

三、安装、配置与 tsconfig.json 详解

3.1 安装与命令

推荐为每个项目单独安装 TypeScript,使用 npm 或 yarn:

npm install typescript --save-dev

或

yarn add typescript --dev

务必把生成的 lockfile 提交到版本库,确保团队成员使用相同版本。运行编译:

npx tsc

或

yarn tsc

也可全局安装(npm install -g typescript);使用 Visual Studio 时可通过 NuGet 安装 Microsoft.TypeScript.MSBuild 包。

安装后得到两个可执行文件:tsc(编译器)和 tsserver(独立语言服务服务器,供 IDE 提供智能补全)。此外也可用 Babel(插件)或 swc 等兼容转译器。

关于 TypeScript 7.0:文档指出其编译器与语言服务已用 Go 重写,利用多线程与共享内存加速完整构建与编辑器反馈;类型检查可通过 --checkers 并行工作线程运行(多线程加速大项目但更耗内存);重写的 --watch 模式改善了跨平台文件监听。7.0 尚未包含编译器 API(截至 2026 年 7 月),依赖 TS 6.0 API 的工具可通过 @typescript/typescript6 或 npm 别名并行运行。

3.2 基本配置方式

TypeScript 可通过 tsc 命令行选项或项目根目录的 tsconfig.json 配置。生成推荐配置:

tsc --init

常用命令行示例:

tsc main.ts // 编译指定文件 main.ts
tsc src/*.ts // 编译 src 目录下所有 .ts 文件
tsc app.ts util.ts --outfile index.js // 将两个文件合并编译为一个 index.js

tsconfig.json 通常与 package.json 放在项目根目录。注意事项:该文件虽为 JSON 格式但支持注释;推荐使用配置文件而非命令行选项。

3.3 核心配置项逐项解析

配置项 作用与要点
target 指定输出到哪个 ECMAScript 版本。现代浏览器选 ES6 即可。ES5 在 TS 6.0 已弃用,7.0 不再支持
lib 指定编译时包含哪些库文件。默认按 target 自动包含对应 API;服务端项目可排除仅浏览器有用的 DOM 库
strict 启用更严格检查,改善类型安全。TS 6.0 起默认开启。开启后:生成带 "use strict" 的代码;将 null/undefined 纳入类型检查;禁止无注解的隐式 any;对原本为 any 的 this 报错
module 设置编译产物的模块系统。运行时由模块加载器加载依赖;常见有 CommonJS(Node 服务端)、AMD/RequireJS(浏览器)等。7.0 不再支持 AMD、UMD、SystemJS(6.0 起弃用)
moduleResolution 模块查找策略。现代代码用 nodenext 或 bundler;classic 仅用于 1.6 之前的旧版
esModuleInterop 允许从没有 default 导出的 CommonJS 模块做默认导入:import MyLibrary from "my-library" 替代 import * as MyLibrary from "my-library"。6.0 起该安全行为总是开启
jsx 仅影响 .tsx(ReactJS)。preserve 保留 JSX 生成 .jsx 交后续工具(如 Babel)处理;react 使用内置 React.createElement 转换
skipLibCheck 跳过对第三方包整个类型定义文件的检查,缩短编译时间(仍会用这些定义检查你的代码)
files 始终纳入编译的具体文件列表
include 纳入编译的文件列表,支持 glob 模式(** 任意子目录、* 任意文件名、? 可选字符)
exclude 排除的文件列表,如 node_modules 或测试文件
importHelpers 将转译辅助函数从 tslib 模块导入而非在各文件中重复内联,使产物更精简

3.4 TypeScript 6/7 中已失效的弃用项

以下旧配置在 TS 6.0 被弃用、7.0 起报错或无效果,迁移时需注意:

  • target: es5;
  • downlevelIteration;
  • moduleResolution: node/node10;
  • module: amd/umd/systemjs/none;
  • baseUrl;
  • moduleResolution: classic;
  • 关闭 esModuleInterop 或 allowSyntheticDefaultImports;
  • 关闭 alwaysStrict;
  • 命名空间声明中的 module 关键字;
  • import 中的 asserts;
  • 使用 skipDefaultLibCheck 时的 /// <reference no-default-lib />;
  • 存在本地 tsconfig.json 时在命令行直接传文件路径(除非使用 --ignoreConfig)。

3.5 迁移到 TypeScript 的实战建议

大型项目推荐渐进式迁移,TS 与 JS 并存:

  1. 接入构建流程:开启 allowJs,让 .ts/.tsx 与现有 JS 并存;迁移初期关闭 noImplicitAny(因 TS 对 JS 文件无法推断的变量会推断为 any)。
  2. 保证测试运行:使用 ts-jest 让 Jest 支持 TS 测试。
  3. 补充类型声明:为第三方库安装 DefinitelyTyped 类型:npm install --save-dev @types/package-name 或 yarn add --dev @types/package-name。
  4. 自底向上迁移模块:按依赖图从叶子模块开始转换;可用 madge 可视化依赖图。优先转换工具函数、外部 API/规范相关代码;可从 Swagger、GraphQL、JSON schema 自动生成类型定义(优先从规范而非原始数据生成,以免遗漏边界情况)。迁移期间避免重构代码,专注添加类型。
  5. 开启 noImplicitAny:强制所有类型已知且已定义。

迁移辅助手段:在 JS 文件中使用 @ts-check 指令启用温和的类型检查,TS 会尝试通过 JSDoc 风格注释推断类型(仅在迁移最早期考虑使用 JSDoc 注解);建议保持 noEmitOnError 默认为 false,以便报错时仍能生成 JS 源码。

四、类型系统探索:结构、集合与推断

4.1 语言服务(tsserver)

TypeScript 语言服务(tsserver)提供错误报告、诊断、保存时编译、重命名、跳转到定义、补全列表、签名帮助等功能,IDE 依靠它实现 IntelliSense,与 VS Code 无缝集成(Coc 等工具也使用它)。开发者还可通过专用 API 编写语言服务插件,例如 typescript-styled-plugin 为 styled components 的 CSS 属性提供语法错误报告与 IntelliSense。

4.2 结构化类型系统

TypeScript 基于结构化类型:类型兼容性由实际结构决定,而非名称或声明位置(后者是 C#、C 等名义类型系统)。这与 JavaScript 运行时的鸭子类型行为一致:

type X = { a: string };
type Y = { a: string };
const x: X = { a: 'a' };
const y: Y = x; // Valid

4.3 类型比较的基本规则

比较是递归的,对任意层级嵌套类型生效:

  • X 兼容 Y:Y 至少具有与 X 相同的成员(成员多的可赋给成员少的);
  • 函数参数按类型而非参数名比较;函数返回类型必须相同;源函数返回类型必须是目标函数返回类型的子类型;
  • 省略函数参数合法(如 map 的回调);源类型的多余可选参数合法;目标类型多出的可选参数也合法;剩余参数视为无限个可选参数;
  • 重载函数:重载签名必须与实现签名兼容;
  • 函数参数比较采用双变(bivariance):源与目标参数彼此可赋为超类型或子类型即可;
  • 枚举可与数字互相比较,但不同枚举之间的比较非法;
  • 类实例比较会检查私有/受保护成员;比较不关心继承层级差异;
  • 泛型类型按代入泛型参数后的最终结构比较:泛型参数参与最终结构的不可兼容,未参与的则兼容;未指定泛型参数时按 any 处理。

可赋值性速查(严格模式下):

let a: number = 1;
a = 2; // Valid:任何类型可赋给自己
let c: any; c = 1; // Valid:任何类型可赋给 any
let d: unknown; d = 1; // Valid:任何类型可赋给 unknown
let e: unknown; let e3: number = e; // Invalid:unknown 只能赋给自身与 any
let f: never; f = 1; // Invalid:没有东西可赋给 never
let g: void; g = 1; // Invalid:void 只能与 any 互相赋值

开启 strictNullChecks 后,null/undefined 行为类似 void;否则类似 never。

4.4 类型即集合(Set Theory)

在 TypeScript 中,类型是可能值的集合(值域)。核心任务是检查一个集合是否为另一个集合的子集:

集合论概念 TypeScript 说明
空集 never 除自身外不包含任何值
单元素集 undefined/null/字面量类型
有限集 boolean/联合
无限集 string/number/object
全集 any/unknown 每个元素都是 any 的成员;unknown 是类型安全的 any

对应关系速查:值可赋给 T ⇔ 值 ∈ T;T1 可赋给 T2 ⇔ T1 ⊆ T2;T1 extends T2 ⇔ T1 ⊆ T2;T1 | T2 ⇔ 并集;T1 & T2 ⇔ 交集;unknown ⇔ 全集。注意 extends 在此与 OOP 类继承无关。由于是结构化类型,两个类型可以部分重叠而互不为子类型。

4.5 类型声明、断言与 ambient 声明

  • 类型声明:const x: X = {...},对象不符即报错(含多余属性检查)。
  • 类型断言(as):告诉编译器你掌握更多信息,压制错误。适合 DOM 场景:document.getElementById('my_input') as HTMLInputElement;也可用于键重映射(结合模板字面量映射类型)。断言不做多余属性检查,因此已知结构时优先用类型声明。
  • Ambient 声明:.d.ts 文件描述 JS 代码类型,用于标注现有 JS 库。可通过 /// <reference path="./library-types.d.ts" /> 引入,也可在 JS 文件中结合 // @ts-check 使用;declare 关键字为现有 JS 代码定义类型而不导入。

4.6 多余属性检查、弱类型与新鲜度

  • 多余属性检查:结构化类型允许“成员超集”,但对象字面量直接赋值/传参时,多余属性会报错(防止拼写错误)。
  • 弱类型:所有属性均可选。TS 认为给弱类型赋一个无重叠的值是错误;可通过 as 断言或添加 [prop: string]: unknown 索引签名绕过(后者更推荐)。
  • 新鲜度(Freshness):对象字面量创建时被视为“新鲜”,直接赋值/传参时执行多余属性检查;一旦被拓宽或断言,新鲜度即消失。
type X = { a: string };
let x: X;
x = { a: 'a', b: 'b' }; // Invalid:新鲜度检查
let y = { a: 'a', b: 'b' };
const fn = (x: X) => console.log(x.a);
fn(y); // Valid:拓宽后无新鲜度检查

4.7 类型推断、最佳公共类型与上下文类型

  • 无注解时,TS 在变量初始化、成员初始化、参数默认值、函数返回类型处推断类型。
  • 多表达式推断寻找“最佳公共类型”:[1, 'x', 1, null] 推断为 (string | number | null)[];找不到则退化为联合:[new RegExp('x'), new Date()] → (RegExp | Date)[]。
  • 上下文类型:根据变量所在位置推断,例如 window.addEventListener('click', function (e) {}) 中 e 被推断为 MouseEvent(来自 lib.d.ts 的 ambient 声明)。

4.8 类型拓宽与 const

拓宽(widening):无注解变量由初始值推断为更宽类型,只能从窄到宽。let x = 'x' 推断为 string。控制拓宽的方式:

  • const:const x = 'x' 推断为字面量 'x';
  • 类型参数上的 const 修饰符(TS 5.0):function identity<const T>(value: T) 使 { a: 'a', b: 'b' } 推断为 { a: "a"; b: "b" } 而非 { a: string; b: string };
  • as const 断言:{ x: 3 as const }、整个对象 as const、元组 [1, 2, 3] as const → readonly [1, 2, 3]。

显式类型注解可收窄推断:const v: { x: 1 | 2 | 3 } = { x: 1 },之后 v.x = 100 非法。

4.9 类型窄化(Narrowing)

将一般类型窄化为更具体的类型,方式包括:

  • 条件语句:if (x !== undefined) { x += 100; };
  • 抛错/提前返回:if (x === undefined) throw 'error'; 之后 x 收窄为 number;
  • 可辨识联合:通过 type/kind 等判别属性在 switch 中收窄;
  • 用户自定义类型守卫:const isValid = (item: string | null): item is string => item !== null; 使 data.filter(isValid) 得到 string[];
  • switch-true 窄化(TS 5.3):用 switch (true) 配合逻辑条件取代冗长的 if/else 链,同时保持类型收窄,类似简化版模式匹配。

4.10 原始类型一览

TS 支持 7 种原始类型(非对象、无方法、不可变):

  • string:文本数据,可跨行(反引号);
  • boolean:true/false;
  • number:64 位浮点,支持十六进制 0xa00d、二进制 0b1010、八进制 0o633;
  • bigint:大于 2^53 - 1 的整数,BigInt(9007199254740991) 或 9007199254740991n;不能与 number 混用,目标需 ES2020+;
  • symbol:唯一标识符,可作对象键避免命名冲突;
  • null / undefined:undefined 表示未赋值(非故意缺失),null 表示明确无值(故意缺失);
  • 数组:string[] / Array<string> / Array<string | number>;只读数组 readonly string[] / ReadonlyArray<string>;元组 [string, number] 与只读元组 readonly [string, number];
  • any:任何值,关闭类型检查。避免用它压制错误;新项目开启 noImplicitAny 让编译器对隐式 any 报错。

五、类型注解、修饰符与常见类型构造

5.1 类型注解、可选属性与只读属性

  • 类型注解:const x: number = 1;简单类型大多可由推断省略;
  • 可选属性:b?: number;
  • 只读属性:readonly 修饰符防止重写(非深度不可变)。

5.2 索引签名与类型扩展

  • 索引签名:[key: string]: T 定义未知键的类型;注意 JS 会自动把数字索引转为字符串索引;
  • 扩展类型:interface Y extends X(可多继承 extends A, B);extends 仅用于接口与类,type 用交集 A & B;type 可被 interface 扩展,反之不行。

5.3 字面量类型与字面量推断

字面量类型是更宽类型内的单元素集,包括字符串、数字、布尔字面量。典型用法:

type O = 'a' | 'b' | 'c';
const a = 'a'; // 字符串字面量类型
let o = { x: 'a' }; // 推断为 string(可被修改)

对对象属性,TS 默认推断为宽类型 string,会导致无法赋给窄联合。解决:x: 'a' as const 或 x: 'a' as X。

5.4 strictNullChecks

strictNullChecks 强制严格 null 检查:变量/参数只有在显式声明为 null | undefined 联合时才能接收这些值,否则报错,从源头避免运行时错误。

5.5 枚举(Enum)

  • 数字枚举:默认从 0 递增,可自定义起始值(后续成员自动递增);
  • 字符串枚举:如 English = 'EN'(允许字符串与数字成员混用的异构枚举);
  • 常量枚举 const enum:编译期内联值并移除枚举本身(不可有计算成员,独立库中通常不推荐);
  • 反向映射:数字枚举可值→名(Grade[90] → 'A'),字符串成员不生成反向映射;
  • Ambient 枚举:在 .d.ts 中声明、无实现的枚举;
  • 计算成员与常量成员:常量成员编译期求值(Blue = Red + Green),计算成员运行期求值(Green = Math.pow(2, 2))。枚举表达为成员类型的联合(E = E.A | E.B | E.C)。

5.6 窄化技术深化

  • typeof 守卫:typeof x === 'number';
  • 真值窄化:if (name) 排除 null/undefined/空串等 falsy 值;
  • 相等窄化:与 switch、===/!== 等配合;
  • in 操作符:'breed' in pet 区分对象成员;
  • instanceof:按构造函数区分类实例(如 Square/Rectangle 面积计算)。

5.7 赋值窄化与控制流分析

  • 赋值窄化:value = 'hello' 后按 typeof 分别处理 string 与 number;
  • 控制流分析(CFA):TS 4.4 起不仅作用于 if 块内,也作用于条件表达式与经 const 变量间接引用的判别属性。注意:只有 const 引用且函数体内未被重新赋值的间接引用才能收窄(let 或函数体内重新赋值会使收窄失效);条件表达式中最多分析五层间接引用。

5.8 类型谓词、可辨识联合、never 与穷尽性检查

  • 类型谓词:value is string 形式;TS 5.5 起可在 .filter 等函数中自动推断谓词(如自动识别 x !== undefined 过滤,但 !!x 这类模糊检查不行);
  • 可辨识联合:用 kind 等共同判别属性在 switch 中收窄;
  • never 类型:表示永不发生的值,用于穷尽检查。当联合的所有分支都被处理完后,default 分支中的变量为 never:
    type Direction = 'up' | 'down';
    const move = (direction: Direction) => {
        switch (direction) {
            case 'up': break;
            case 'down': break;
            default:
                const exhaustiveCheck: never = direction; // 新增成员未处理会报错
        }
    };
    

5.9 对象类型、元组与集合运算

  • 对象类型:interface / type alias / 匿名对象均可描述结构;
  • 匿名元组:type Point = [number, number],固定长度与顺序;
  • 命名元组:type Tuple2 = [a: string, b: string](可混合命名与匿名元素);
  • 固定长度元组:[10, 'hello'] as const 后不可 push;
  • 联合类型:string | number;
  • 交集类型:X & Y 拥有全部属性;
  • 索引访问:Dictionary<T>[key]、Person['age']、MyTuple[2]。

5.10 从值/函数/模块获取类型

  • 类型来自值:const x = 'x' → const 时字面量 'x',let 时拓宽为 string;
  • 类型来自函数返回:const add = (x: number, y: number) => x + y → 返回 number;
  • 类型来自模块:import { add } from 'calc' 后 add(1, 2) 自动为 number。

六、类型操作与工具类型

6.1 映射类型与修饰符

映射类型通过 keyof 遍历现有类型属性并转换:

type MyMappedType<T> = { [P in keyof T]: T[P][] };

修饰符:

  • readonly / +readonly:设为只读;
  • -readonly:取消只读;
  • ?:设为可选。

典型实现:

type ReadOnly<T> = { readonly [P in keyof T]: T[P] };
type Mutable<T> = { -readonly [P in keyof T]: T[P] };
type MyPartial<T> = { [P in keyof T]?: T[P] };

6.2 条件类型、分配条件类型与 infer

  • 条件类型:type IsArray<T> = T extends any[] ? true : false;
  • 分配条件类型:裸类型参数条件会对联合的每个成员分别应用:type Nullable<T> = T extends any ? T | null : never; → number | boolean | null;
  • infer:在条件类型中提取泛型参数:type ElementType<T> = T extends (infer U)[] ? U : never;

6.3 预定义条件类型

Exclude<Type, Excluded>(移除可赋给 Excluded 的成员)、Extract<Type, Union>(提取可赋给 Type 的成员)、NonNullable<Type>(移除 null/undefined)、ReturnType<Type>(函数返回类型)、Parameters<Type>(参数类型元组)、Required<Type>(全部必选)、Partial<Type>(全部可选)、Readonly<Type>(全部只读)。

6.4 模板联合类型

在类型层面拼接文本:

type Status = 'active' | 'inactive';
type Products = 'p1' | 'p2';
type ProductId = `id-${Products}-${Status}`;
// "id-p1-active" | "id-p1-inactive" | "id-p2-active" | "id-p2-inactive"

6.5 any、unknown、void、never 的定位

  • any:通用超类型,关闭类型检查。建议:限制使用范围、不返回 any、用 @ts-ignore 代替压制错误;
  • unknown:类型安全的 any,只能赋给 any 与自身;使用前必须收窄或断言;
  • void:函数不返回值;
  • never:永不返回(死循环、抛错),用于穷尽检查。

6.6 interface 与 type 的对比

  • 声明合并:interface 支持同名合并,type 不支持;
  • 扩展:interface 用 extends(不能扩展联合等复杂类型),type 用 & 交集;
  • 联合与交集:type 更灵活(|/& 直接可用),interface 没有内建交集支持(可间接通过联合表示)。

七、面向对象:类、继承与装饰器

7.1 类的基本语法、构造函数与重载

类定义成员、构造函数与公共方法;通过 new 创建实例。构造函数可重载(多个签名 + 单个兼容实现,可用可选参数实现):

class Person {
    name: string;
    age: number;
    constructor();
    constructor(name: string);
    constructor(name: string, age: number);
    constructor(name?: string, age?: number) {
        this.name = name ?? 'Unknown';
        this.age = age ?? 0;
    }
}

私有/受保护构造函数:私有用于强制单例或工厂方法;受保护用于禁止直接实例化的基类(子类可 super() 调用)。

7.2 访问修饰符、getter/setter 与 accessor

  • private:仅类内部;protected:类内及派生类;public:任意访问;
  • get/set:自定义属性读写行为,封装内部状态;
  • 自动访问器(TS 4.9,ECMAScript 新特性):accessor name: string,编译为基于私有字段的 get/set。

7.3 this、参数属性、抽象类与泛型类

  • this 指向当前实例,用于访问/修改内部状态;
  • 参数属性:构造函数参数带 private/public 等修饰符时自动声明并初始化对应属性,消除样板代码;
  • 抽象类:abstract class 定义公共行为并强制子类实现抽象方法;
  • 泛型类:class Container<T> 支持多种类型同时保持类型安全。

7.4 装饰器(Decorators)

装饰器是运行时执行的函数,用于添加元数据、修改行为、校验或扩展功能。TS 5+ 且使用 ES6 时原生支持(5 以下需 experimentalDecorators 或 --experimentalDecorators;注意 TS 5 装饰器不允许装饰参数)。

常见用途:属性变更追踪、方法调用追踪、添加属性/方法、运行时校验、自动序列化/反序列化、日志、鉴权、错误防护。

  • 类装饰器:扩展类(如注入 toString),通过 ClassDecoratorContext 访问上下文;
  • 属性装饰器:修改初始化值(如自动大写 HELLO!);
  • 方法装饰器:包装方法(如 log 记录进入/退出);
  • getter/setter 装饰器:校验返回值(如 @range(1, 100) 越界抛错);
  • 装饰器元数据:通过 Symbol.metadata 访问 context.metadata,可用于调试、序列化、依赖注入。

7.5 继承、多接口、静态成员与属性初始化

  • 单继承:class Dog extends Animal,super() 调用基类构造;TS 不支持传统多继承,但类可 implements 多个接口;
  • class 本质是 ES6 语法糖,最终编译为基于原型的 JS;
  • 静态成员:static memberCount 通过类名访问,无需实例化;
  • 属性初始化:声明处直接赋值、构造函数内赋值、构造函数参数属性三种方式;
  • 方法重载:同一方法多个签名(add(a: number, b: number): number 与 add(a: string, b: string): string),实现签名用联合类型。

八、泛型进阶

8.1 泛型类型、泛型类与约束

  • 泛型用尖括号 <> 参数化类型、函数与接口:function identity<T>(arg: T): T;const getLen = <T,>(data: ReadonlyArray<T>) => data.length(注意 <T,> 尾逗号写法避免与 JSX 歧义);
  • 泛型类:class Container<T>;
  • 约束:<T extends { length: number }> 限制类型参数必须满足某结构,否则报错(printLen(123) 非法);
  • 高阶函数类型推断(3.4 RC 起):泛型参数在 pipe 组合中正确传递,支持 pointfree 风格:
    declare function pipe<A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C;
    const listBox = pipe(list, box); // <T>(a: T) => { value: T[] }
    
  • 上下文窄化:泛型参数在条件语句中可被收窄(typeof value === 'string' 分支内为 string)。

九、模块、命名空间与现代语言特性

9.1 擦除结构化类型、命名空间与符号

  • 擦除结构化类型:对象只需在结构上满足接口即可在要求处使用,无需显式绑定;
  • 命名空间:组织代码、避免命名冲突,export namespace 暴露给外部模块;
  • 符号(Symbol):全局唯一的不可变原始值,可作对象键创建不可枚举属性;WeakMap/WeakSet 现支持 symbol 键。

9.2 三斜线指令

以 /// 开头的特殊注释,为编译器提供处理指令(无运行时影响):

/// <reference path="path/to/declaration/file.d.ts" />  // 引用声明文件
/// <amd|commonjs|system|umd|es6|es2015|none>           // 指定模块格式
/// <strict|noImplicitAny|noUnusedLocals|noUnusedParameters> // 启用编译选项

9.3 从类型创建类型与索引访问

  • 交集/联合/映射/条件组合创建新类型;
  • 索引访问类型:Person['age'] → number、MyTuple[2] → boolean。

9.4 工具类型大全(Utilities)

工具类型 作用 示例
Awaited<T> 递归解包 Promise Awaited<Promise<string>> → string
Partial<T> 全部可选 Partial<Person> → { name?: string; age?: number }
Required<T> 全部必选 Required<Person>(对可选属性生效)
Readonly<T> 全部只读 赋值报错
Record<K, T> 键集 K 对应 T Record<string, Product>
Pick<T, K> 选取指定键 Pick<Product, 'price'> → { price: number }
Omit<T, K> 排除指定键 Omit<Product, 'price'> → { name: string }
Exclude<T, U> 从 T 排除 U Exclude<'a'|'b'|'c', 'a'|'c'> → 'b'
Extract<T, U> 提取 T 中 U → 'a' | 'c'
NonNullable<T> 移除 null/undefined → 'a' | 'b'
Parameters<T> 函数参数元组 → [a: string, b: number]
ConstructorParameters<T> 构造器参数元组 ConstructorParameters<typeof Person>
ReturnType<T> 函数返回类型 → number
InstanceType<T> 类实例类型 InstanceType<typeof Person>
ThisParameterType<T> 提取 this 参数类型
OmitThisParameter<T> 移除 this 参数
ThisType<T> 标记上下文 this 类型
Uppercase/Lowercase/Capitalize/Uncapitalize<T> 字符串大小写转换 Uppercase<'abc'> → "ABC"
NoInfer<T> 阻止泛型推断 fn2<T extends string>(x: T[], y: NoInfer<T>) 报错演示

9.5 错误处理、Mixin 与异步

  • try/catch/finally:按 error instanceof TypeError 等分类处理;自定义错误 class CustomError extends Error;
  • Mixin 类:组合多个类行为,interface MyClass extends Identifiable, Selectable {} + applyMixins 复制原型属性到目标类;
  • 异步特性:Promise、async/await、Fetch API、Web Workers、WebSocket 等均有良好支持;
  • 迭代器与生成器:Iterable<number> + next() 实现迭代器;function* + yield 定义生成器(适合大/无限序列);异步迭代器与异步生成器同样受支持。

9.6 TsDocs/JSDoc 与 @types

  • 用 JSDoc 注解辅助 JS 代码的类型推断(@param {number} base 等);3.7 起可从 JS 的 JSDoc 语法生成 .d.ts;
  • @types 包:npm install --save-dev @types/lodash 提供现有 JS 库的类型定义。

9.7 JSX 与 ES 模块

  • JSX:需在 tsconfig 中设置 jsx。preserve 保留 JSX 交 Babel 等处理;react 使用内置 React.createElement 转换;
  • ES6 模块:target: "es6" + module: "es6" + moduleResolution: "node" + sourceMap + outDir,include: ["src"] 的完整配置示例见原文档。

9.8 现代 JS 特性在 TS 中的使用

  • ES7 幂运算符:2 ** (2 ** 2) → 16(target 需 es2016+,支持 BigInt);
  • for-await-of:遍历异步可迭代对象(target es2018+);
  • new.target:判断是否通过 new 调用构造器;
  • 动态 import():按需/条件加载模块:const widget = await import('./widget');
  • tsc --watch:文件变更自动重编译;4.9 起主要依赖文件系统事件,无法建立事件监听时自动降级为轮询;
  • 非空断言 !:person!.name 声明非 null/undefined,消除显式检查;
  • 默认值声明:function greet(name: string = 'Anonymous');
  • 可选链 ?.:person.address?.city → 遇到 null/undefined 返回 undefined;
  • 空值合并 ??:左值为 null/undefined 时返回右值(0 ?? 'baz' → 0);
  • 模板字面量类型:type Id = \Department−{Department}-{Language}-id``;
  • 函数重载:多个签名 + 单个兼容实现;
  • 递归类型:type ListNode<T> = { data: T; next: ListNode<T> | undefined };
  • 递归条件类型:type Json = string | number | boolean | null | Json[] | { [key: string]: Json };type Flatten<T> = T extends Array<infer U> ? Flatten<U> : T;

9.9 Node 的 ECMAScript 模块支持

  • Node.js 15.3.0+ 支持 ES 模块,TS 4.7 起支持 module: "nodenext":
    { "compilerOptions": { "module": "nodenext", "outDir": "./lib", "declaration": true } }
    
  • .mjs/.cjs 对应 TS 的 .mts/.cts;编译分别生成 .mjs/.cjs;package.json 中 "type": "module" 声明 ES 模块项目。

9.10 断言函数、可变元组与包装类型

  • 断言函数:function isNumber(value: unknown): asserts value is number,条件不满足时抛错而非返回 false;与类型守卫(返回布尔)不同;
  • 可变元组(Variadic Tuples,TS 4.0):元组中的展开/剩余元素可为泛型且可出现在任意位置:
    type Bar<T extends unknown[]> = [boolean, ...T, number];
    type A = Bar<[boolean]>; // [boolean, boolean, number]
    function concat<T extends Items, U extends Items>(arr1: T, arr2: U): [...T, ...U] { ... }
    
  • 包装类型:string => String、number => Number、boolean => Boolean、symbol => Symbol、bigint => BigInt。JS 在调用原始值方法时自动装箱。通常应使用原始类型而非包装类型。

9.11 协变与逆变

  • 数组是协变的(但不完全类型安全):animals = dogs 允许;
  • 函数参数:strictFunctionTypes 开启时逆变,否则双变;
  • 协变:F<A> 是 F<B> 的子类型(A ⊆ B)——狗空间可用于动物空间;
  • 逆变:关系反转——能处理任何动物的函数可用于只处理狗的场景;
  • 可选 variance 注解(TS 4.7):type AnimalCallback<out T> = () => T(协变)、type AnimalCallback<in T> = (value: T) => void(逆变)。

9.12 模板字符串索引签名、satisfies 与类型专用导入导出

  • 模板字符串索引签名(TS 4.4 起支持 symbol 与模板字符串模式索引):
    type MyKeys = `key-${string}`;
    type MyObject = { [uniqueSymbol]: string; [key: MyKeys]: number; };
    
  • satisfies 操作符:既校验类型满足接口,又保留精确推断。对比:类型注解会丢失精确信息,as 断言同样丢失推断,而 satisfies 两者兼得:
    const user3 = { name: 'Simon', attributes: ['dev', 'admin'] } satisfies User;
    user3.attributes?.map(console.log); // 正确推断 string[]
    
  • 仅类型导入/导出:import type { House } from './house.ts'(允许扩展名 .ts/.mts/.cts/.tsx);支持 import type T from './mod'、import type * as Types from './mod'、export type { T } from './mod' 等形式,减小打包体积。

9.13 资源管理与前沿特性

  • using 声明(TS 5.2,ECMAScript 显式资源管理):块作用域不可变绑定,离开作用域时执行 Symbol.dispose,按声明逆序释放;需 polyfill Symbol.dispose、Symbol.asyncDispose、DisposableStack、AsyncDisposableStack、SuppressedError,并配置:
    { "compilerOptions": { "target": "es2022", "lib": ["es2022", "esnext.disposable", "dom"] } }
    
    可释放资源需实现 Disposable 接口([Symbol.dispose](): void);
  • await using:异步释放,资源实现 AsyncDisposable([Symbol.asyncDispose](): Promise<void>);using/await using 可用于 for、for-in、for-of、for-await-of、switch;
  • 导入属性(Import Attributes,TS 5.3):import config from './config.json' with { type: 'json' },动态导入 import('./config.json', { with: { type: 'json' } }),告诉运行时如何对待模块(JSON 等),与 CSP 一致;
  • 正则字面量语法检查(TS 5.5.4):编译期检查常见正则错误(非法语法、错误反向引用、目标版本不支持的特性),但 new RegExp("...") 字符串不检查;
  • import defer:延迟执行模块直到真正使用其导出(仅支持 import defer * as name from "module"),避免无谓工作与副作用。

十、项目结构速览与延伸阅读

想深入了解本文内容的完整章节版本,可在仓库中直接阅读:

结语

本文完整梳理了 The Concise TypeScript Book 的核心知识体系:从 TypeScript 的定位与编译模型、tsconfig 全量配置项、结构化类型系统与集合论视角,到类型推断与窄化、原始类型与枚举、面向对象特性、泛型、类型操作与工具类型,以及资源管理、导入属性、satisfies 等前沿能力。配合仓库中的章节源码与在线网站实现,可作为日常开发与学习 TypeScript 7 的完整参考手册——既能当系统教程,也能当随手查阅的速查指南。

登录后查看全文
typescript-book