The Concise TypeScript Book:面向 TypeScript 7.0 的简明实战指南

原创2026-09-23 19:26:591,648 阅读
文章标签:文档教程

The Concise TypeScript Book:面向 TypeScript 7.0 的简明实战指南

导读

本文以开源仓库《The Concise TypeScript Book》(泰文版见 README-th_TH.md,英文原版见 README.md)为核心内容,系统梳理 TypeScript 7.0 从语言基础、类型系统、tsconfig 配置到高级类型编程与工程实践的完整知识体系。读完本文,你将掌握 TypeScript 的类型注解与推断机制、结构化类型与窄化技巧、interface/type/class/generic 的组合运用、全套 Utility Types,以及结合仓库真实配置(如 tools/tsconfig.json)落地工程的迁移与构建方案。

本书的完整书籍内容按章节组织在 website/src/content/docs/book/(英文)与 website/src/content/docs/th-th/book/(泰文)等目录中,本文在讲解每个主题时都会给出对应的源码级佐证。

一、认识 TypeScript:它是什么,为什么值得使用

TypeScript 是一门建立在 JavaScript 之上的强类型编程语言,由 Anders Hejlsberg 于 2012 年设计,现由 Microsoft 以开源项目形式维护。它编译为 JavaScript,可在任何 JavaScript runtime(浏览器、Node.js 等)中运行,并同时支持函数式、泛型、命令式与面向对象等多种编程范式。

选择 TypeScript 的核心收益包括:

  • 静态类型 + 可选的强类型检查(strict 模式);
  • 强大的类型推断(Type Inference);
  • 可直接使用 ES6/ES7 等现代 JavaScript 特性;
  • 跨平台、跨浏览器兼容;
  • 基于 IntelliSense 的完善工具链支持。

强类型语言允许开发者在类型定义中表达程序的约束与行为,从而在运行前验证软件正确性、预防缺陷,这对大型应用尤其有价值。

二、TypeScript 与 JavaScript 的关系

  • TypeScript 源码使用 .ts / .tsx 扩展名,JavaScript 使用 .js / .jsx;.tsx / .jsx 可包含 JSX 语法(React UI 开发)。
  • 语法层面,TypeScript 是 JavaScript(ECMAScript 2015)的带类型超集:所有 JavaScript 代码都是合法的 TypeScript 代码,反之则不一定成立。
  • 纯 JS 函数改为 .ts 后无需修改即可运行,但一旦加上类型注解,就必须先编译才能运行:
const sum = (a: number, b: number): number => a + b; // 未编译时会产生语法错误
  • 类型系统深受 JavaScript 运行时行为影响,例如 + 运算符在 JS 中既可拼接字符串也可做数值加法,TypeScript 同样如此建模:const result = '1' + 1; 结果类型为 string。
  • TypeScript 还会把 JS 中"非常规"的写法标记为错误,例如 const result = 1 + true; 会报 Operator '+' cannot be applied to types 'number' and 'boolean'.。

代码生成:类型检查与编译彼此独立

TypeScript 编译器承担两项独立职责:检查类型错误和编译为 JavaScript。类型在编译期间会被完全擦除,因此类型错误的存在并不妨碍产出可运行的 JS:

const add = (a: number, b: number): number => a + b;
const result = add('x', 'y'); // 编译期报错,但 JS 仍可输出并运行

也正因类型在编译后被擦除,运行时无法直接检查 TypeScript 类型。animal instanceof Dog(Dog 仅为 interface)会报错。若需要在运行时区分类型,常见做法是使用"带标签的联合(tagged union)":

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

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

与之相对,class 关键字既是类型也是运行时值,因此可以配合 instanceof 在运行时做判断。由于所有类型都会被擦除,TypeScript 对运行时性能没有影响,只增加少量构建期开销。

Downleveling:今天就用上现代 JavaScript

TypeScript 可以向下编译到 ECMAScript 3(1999 年)以来任意已发布的 JS 版本,即 Downleveling。借助它可以在老 runtime 上使用现代特性:ES Modules 替代 AMD/CommonJS、class 替代 prototype、let/const 替代 var、for-of/.forEach 替代传统 for、箭头函数、解构赋值、属性简写与计算属性名、函数默认参数等。注意:transpile 到旧版本时可能产生比 native 实现更多的开销。

三、安装、配置与迁移实战

安装与运行

Visual Studio Code 对 TypeScript 支持极佳,但不自带编译器。推荐在项目内安装而非全局安装,保证构建可预测:

npm install typescript --save-dev
# 或
yarn add typescript --dev

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

npx tsc
# 或
yarn tsc

临时使用可 npx tsc 或全局安装 npm install -g typescript;Visual Studio 用户可在 NuGet Package Manager Console 执行 Install-Package Microsoft.TypeScript.MSBuild。安装后会得到两个可执行文件:tsc(编译器)与 tsserver(独立语言服务器,供 IDE 实现智能补全)。此外还有 Babel(插件)与 swc 等兼容 transpiler 可选。

书中特别说明:TypeScript 7.0 用 Go 重写了编译器与语言服务,采用共享内存多线程等优化;类型检查可通过 --checkers 并行化(worker 越多越快但越耗内存);重写的 --watch 模式改善了跨平台文件监听。截至 2026 年 7 月 TypeScript 7.0 尚不提供 compiler API,需要 6.0 API 的工具可通过 @typescript/typescript6 或 npm alias 与 7.0 并行使用。

配置:tsc CLI 与 tsconfig.json

可通过 tsc 的 CLI 选项或项目根目录的 tsconfig.json 配置。用 tsc --init 生成带推荐值的初始配置;执行 tsc 时会自动使用最近的 tsconfig.json。常用 CLI 示例:

tsc main.ts                          // 编译单个文件
tsc src/*.ts                         // 编译 src 下所有 .ts
tsc app.ts util.ts --outfile index.js // 合并为单个 JS 文件

tsconfig.json 要点:虽然是 JSON 格式但支持注释;推荐用它而非命令行选项。

核心配置项详解

配置项 作用与要点
target 指定 emit 到的 ECMAScript 版本。现代浏览器可选 es6;es5 在 6.0 被弃用,7.0 不再支持
lib 指定编译时引入的库文件。TypeScript 会按 target 自动包含对应 API,但可按需裁剪,如服务端项目可排除 DOM 库
strict 开启更强检查:逐文件 emit "use strict";在类型检查中纳入 null/undefined;禁止无注解时的隐式 any;对 this 表达式(否则为 any)报错。6.0 起默认开启
module 设定模块系统(UMD、System、ESNext、ES2015/ES6、ES2020 等),需与目标环境的 loader(Node 的 CommonJS、浏览器的 RequireJS)匹配。AMD/UMD/SystemJS 在 6.0 弃用、7.0 不再支持
moduleResolution 模块解析策略。现代代码用 nodenext 或 bundler;classic 仅适用于 1.6 之前的旧版
esModuleInterop 允许从未以 default 导出的 CommonJS 模块做默认导入(import MyLibrary from "my-library"),并在 emit 的 JS 中加 shim。6.0 起该安全 interop 行为恒为开启
jsx 仅作用于 ReactJS 的 .tsx 文件,控制 JSX 如何编译。preserve 保留 JSX 输出 .jsx 交由 Babel 等继续转换
skipLibCheck 跳过对第三方包内部 .d.ts 的类型检查,减少编译时间(仍会用这些类型定义检查你的代码)
files 编译器必须包含的显式文件列表
include 需要包含的 glob 模式(如 **/*、*、?)
exclude 排除的文件,如 node_modules、测试文件

TypeScript 6.0 起以下旧配置/语法从弃用变为 7.0 中的 hard error 或 no-op:target: es5、downlevelIteration、moduleResolution: node/node10、module: amd/umd/systemjs/none、baseUrl、moduleResolution: classic、关闭 esModuleInterop/allowSyntheticDefaultImports、关闭 alwaysStrict、namespace 声明中的 module 关键字、import 上的 asserts、skipDefaultLibCheck 下的 /// <reference no-default-lib />、以及未加 --ignoreConfig 时对带本地 tsconfig.json 的 CLI 文件路径。

importHelpers:对某些高级/降级特性 TypeScript 默认会复制 helper 代码到每个使用文件,开启 importHelpers 后改为从 tslib 模块导入,产出更高效。

仓库佐证:本项目构建工具自身就严格使用了上述配置——tools/tsconfig.json 中设置了 "target": "es2022"、"strict": true、"noImplicitAny": true、"esModuleInterop": true、"skipLibCheck": true,lib 则按需引入了 es2022、esnext.disposable、esnext.decorators 与 dom,正是 lib 可按需裁剪/叠加的实际范例;website/tsconfig.json 则通过 extends: "astro/tsconfigs/strict" 继承 strict 基线,体现配置文件组合复用的工程实践。

迁移到 TypeScript 的五步建议

大型项目应渐进式迁移(仅小项目可一次性完成),书中给出五步法:

  1. 引入构建链:开启 allowJs 让 .ts/.tsx 与既有 JS 共存;迁移初期建议关闭 noImplicitAny(JS 无法推断时回退到 any)。
  2. 保证测试可用:确保 JS 测试与 TS 文件共存,如 Jest 用户可考虑 ts-jest。
  3. 补充第三方类型声明:从 DefinitelyTyped 检索并安装 npm install --save-dev @types/package-name。
  4. 自底向上逐模块迁移:沿依赖图从叶子模块开始(工具函数、外部 API 相关代码优先);可从 Swagger、GraphQL、JSON schema 自动生成类型;无规范时再从原始 JSON 数据生成,但优先基于规范;迁移期间避免重构,只加类型。
  5. 最终开启 noImplicitAny,强制所有类型已知且已定义。

辅助手段:用 // @ts-check 指令在 JS 文件中启用宽松的类型检查(配合 JSDoc 注释推断定义,仅建议在迁移早期使用);保持 noEmitOnError 为默认的 false,即使报错也能输出 JS。

四、类型系统初探:结构化类型与比较规则

TypeScript Language Service(tsserver)

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

结构化类型(Structural Typing)

TypeScript 基于结构化类型系统:类型的兼容性与等价性取决于实际结构,而非声明名称或位置(区别于 C#/C 的 nominal 系统),其设计灵感来自 JavaScript 运行时的鸭子类型:

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

基础比较规则速查

  • 比较是递归的,作用于任意嵌套层级;X 与 Y 兼容当且仅当 Y 至少包含 X 的全部成员(const r: X = { a: 'A', b: 'B' }; 合法)。
  • 函数参数按类型比较,不按名称;返回值类型必须相同;源函数返回类型必须是目标函数返回类型的子类型。
  • 允许丢弃函数参数(如 map 回调);源类型的额外可选参数合法;目标类型缺少对应参数的可选参数合法;rest 参数视为无限序列的可选参数。
  • 重载签名必须与实现签名兼容,否则报错。
  • 函数参数比较采用 bivariance(源/目标参数可赋给父类型或子类型即可)。
  • Enum 与 number 可互相比较,但不同 Enum 之间的值比较非法;类实例需通过 private/protected 成员兼容性检查;比较检查不关心继承层级差异。
  • Generic 按应用泛型参数后的最终结构比较;未指定类型参数时按 any 处理。

可赋值性总则(重要记忆点):一切类型可赋给自身;一切可赋给 any;一切可赋给 unknown;unknown 只能赋给自身与 any;never 可赋给一切但不可被赋值;void 只与 any 互通。开启 strictNullChecks 后 null/undefined 行为类似 void,否则类似 never。

类型即集合(Types as Sets)

TypeScript 类型可理解为"可能值的集合"(域),其核心工作就是验证一个集合是否为另一个集合的子集:

集合术语 TypeScript 说明
空集 never 除自身外无成员
单元素集 undefined / null / literal —
有限集 boolean / union —
无限集 string / number / object —
全集 any / unknown 一切皆为 any 的成员;unknown 是 any 的类型安全对应物

对应关系:never=∅;literal=单元素集;可赋值 T1 ⊆ T2;T1 extends T2 即子集;T1 | T2 为并集(更宽);T1 & T2 为交集(更窄);unknown 为全集。注意类型层面的 extends 与 OOP 类继承无关。

类型声明、类型断言与 Ambient 声明

  • 类型声明:const x: X = { a: 'a' };,不符合即报错(含多余属性:Object literal may only specify known properties)。
  • 类型断言:as 关键字告知编译器开发者掌握更多信息,如 document.getElementById('my_input') as HTMLInputElement;可用于 key 重映射(mapped type + template literal 生成 prefix_ 前缀属性)。注意断言会跳过过量属性检查,能预知结构时应优先用声明。
  • Ambient 声明:.d.ts 文件描述既有 JS 代码的类型,可来自 DefinitelyTyped(npm install --save-dev @types/library-name),也可用 triple-slash 引用 /// <reference path="./library-types.d.ts" />;declare 关键字可在不导入的情况下为全局/外部代码声明类型占位;JS 文件中可用 // @ts-check 启用。

属性检查、Weak Types 与 Freshness

  • 过量属性检查:将 object literal 赋给变量或作为函数实参时触发;非 literal(如先赋值给中间变量)则只做结构化兼容。
  • Weak Types:全部属性可选的类型。向其赋值"零重叠"的对象会被视为错误(fn({ c: 'c' }) 非法),可用 as 断言或给 index signature 加 unknown 绕过。
  • Freshness(严格对象字面量检查):literal 一旦拓宽(widen)或经过断言,"fresh" 状态即消失,之后只做结构兼容检查。

类型推断、拓宽(Widening)与 const

  • 推断发生在:变量/成员/参数初始化、函数返回值。多表达式时取"最合适的公共类型",否则返回联合(如 [new RegExp('x'), new Date()] → (RegExp | Date)[]);也支持上下文类型(contextual typing),如 click 回调中的 e 被推断为 MouseEvent。
  • 拓宽:由窄到宽(let x = 'x' → string),不可反向;控制手段是 const、显式注解与断言。
  • const 推断:const x = 'x' 推断为 literal 'x'。
  • const 修饰符(TS 5.0+):泛型参数上的 const T 使推断尽可能精确(identity({ a: 'a', b: 'b' }) → { a: "a"; b: "b" })。
  • const 断言:3 as const、整对象 as const、元组 [1, 2, 3] as const → readonly [1, 2, 3]。

类型窄化(Narrowing)

窄化把宽类型在分支内收窄为更具体的类型,手段包括:

  • 条件:if (x !== undefined) 内 x 收窄为 number。
  • throw/return 提前退出:if (x === undefined) throw 'error'; 之后 x 为 number。
  • 可判别联合(Discriminated Union):用 type/kind 等字面量标签在 switch 中分流并收窄。
  • 用户自定义 type guard:const isValid = (item: string | null): item is string => item !== null;,配合 filter 获得精确类型。
  • switch-true 窄化(TS 5.3):用 switch (true) { case typeof x === 'string': ... } 替代复杂 if/else 链,兼具可读性与窄化能力。

五、基础类型与常用类型特性

TypeScript 有 7 种基础类型(非对象、无方法、不可变):string、boolean、number、bigint、symbol、null、undefined。

  • string:单双引号或模板字符串(反引号可跨行)。
  • number:64 位浮点,支持十进制、十六进制(0xa00d)、二进制(0b1010)、八进制(0o633)。
  • bigint:BigInt(9007199254740991) 或字面量加 n(9007199254740991n);不能与 number 混用、不能用 Math;target 需 ES2020+。
  • symbol:唯一标识,可作对象属性键防命名冲突。
  • null/undefined:undefined 表示"尚未定义",null 表示"有意缺失"。
  • array:string[] 或 Array<string>,支持联合 Array<string | number>;只读数组 readonly string[] / ReadonlyArray<string>(push 非法);支持元组 [string, number] 与只读元组。
  • any:表示"任意值",会跳过类型检查。不应用于掩盖编译错误;新项目应开启 noImplicitAny;迁移期可临时使用。

类型注解:var/let/const、函数参数、返回值均可注解;有默认值时可省略参数注解;建议注解签名、给对象字面量加类型。

可选属性:b?: number,可配默认值 ({ a, b = 100 }: X) => a + b。 只读属性:readonly a: number、Readonly<{ a: number }>、readonly [index: number]: string;只阻止重写,不保证深度不可变。 索引签名:string/number/symbol 皆可,注意 JS 会把 number 索引自动转为 string(k[1] 与 k['1'] 等价)。 扩展类型:interface Y extends X、interface Y extends A, B(多继承);type 用 & 交集扩展;type 可被 interface 扩展,反之不可。 字面量类型:字符串/数字/布尔 literal,常用 type O = 'a' | 'b' | 'c';。 字面量推断:const x = 'x' → literal;let y = 'y' → string;对象属性默认拓宽为 string,可用 as const 或 as X 修正。 strictNullChecks:开启后只有显式声明 null | undefined 联合的变量/参数才能接收空值。

六、Enum 详解

enum 是命名常量集合,可用字符串或数值初始化:

enum Color {
    Red = '#ff0000',
    Green = '#00ff00',
    Blue = '#0000ff',
}
  • 数值枚举:默认从 0 自增;可指定起始值(Small = 10 后 Medium 为 11)。
  • 字符串枚举:值为字符串;也允许数字/字符串混合枚举。
  • const enum:编译期已知全部值并被内联替换(console.log('EN' /* Language.English */));不可含计算成员,且因删除枚举可能影响独立库,一般不作首选。
  • 反向映射:数值成员生成 Grade[90] → 'A';字符串成员不生成反向映射。
  • Ambient enum:在 .d.ts 中声明、无实现,跨文件安全使用常量集合。
  • 常量/计算成员:常量成员编译期求值(Blue = Red + Green → 6);计算成员运行时求值(Math.random())。枚举可表示为成员类型的联合(E = E.A | E.B | E.C)。

七、窄化技术全家桶

  • typeof 类型守卫:typeof x === 'number' 分支内收窄。
  • 真值窄化:if (name) 排除 null/undefined/空字符串等 falsy 值。
  • 相等性窄化:switch (status) + ===/!==/==/!= 收窄联合。
  • in 操作符:按属性是否存在区分 Dog | Cat。
  • instanceof:按构造器区分,如 shape instanceof Square 后直接访问 width * width。
  • 赋值窄化:let value: string | number; value = 'hello'; 后按 typeof 分支。
  • 控制流分析(TS 4.4+):窄化可透过 const 变量间接引用(const isString = typeof x === 'string'; if (isString) { x.length; });注意若 isString 为 let 或对象在函数体内被重新赋值,则不会窄化;条件表达式最多分析五层间接引用。
  • 类型谓词(Type Predicates):value is string 返回布尔并收窄类型;TS 5.5 起 .filter 等函数可自动推断谓词([1, null, 2].filter(x => x !== null)),但仅限明确检查(!!x 之类不适用)。
  • 可判别联合 + never + 穷尽检查:switch (shape.kind) 按判别属性收窄;穷尽检查在 default 分支用 const exhaustiveCheck: never = direction;,新增联合成员而漏处理时编译器即报错。

八、对象类型、元组与类型组合

  • 对象类型:interface 或 type 别名均可描述;支持匿名内联({ a: number; b: number })。
  • 元组:type Point = [number, number];可命名(labeled):[a: T, b: T],允许与匿名混用;固定长度元组用 as const 固化(x.push(2) 报错)。
  • 联合类型:string | number。
  • 交集类型:X & Y 同时拥有双方属性。
  • 类型索引:type Dictionary<T> = { [key: string]: T };。
  • 从值取类型:const x = 'x' 推断为 literal(const)或 string(let)。
  • 从函数返回取类型:const add = (x: number, y: number) => x + y; 自动推断返回 number。
  • 从模块取类型:跨模块导入后类型自动传播。

九、类型操纵:Mapped、Conditional 与 infer

  • Mapped Type:{ [P in keyof T]: T[P][] } 将每个属性映射为新形式(如数组化)。
  • Mapped Type 修饰符:readonly/+readonly 只读、-readonly 可变、? 可选——ReadOnly<T>、Mutable<T>、MyPartial<T> 即由此实现。
  • 条件类型:IsArray<T> = T extends any[] ? true : false。
  • 可分发条件类型(Distributive):对联合逐成员变换,如 Nullable<number | boolean> → number | boolean | null。
  • infer:在条件类型中提取泛型参数,如 ElementType<T> = T extends (infer U)[] ? U : never。
  • 预定义条件类型:Exclude、Extract、NonNullable、ReturnType、Parameters、Required、Partial、Readonly 等内置类型(详见下节)。
  • 模板联合类型:type ProductId = `id-${Products}-${Status}` 组合出笛卡尔积形式的字面量联合。

十、any、unknown、void、never 四大特殊类型

  • any:超级类型,可代表任意值;使用建议——仅在不真正知道类型时使用、不要从函数返回 any、想屏蔽错误时优先 @ts-ignore。
  • unknown:any 的类型安全替代;只可赋给 any/unknown,使用前必须收窄或断言:
const add = (a: unknown, b: unknown): number | undefined =>
    typeof a === 'number' && typeof b === 'number' ? a + b : undefined;
  • void:函数不返回值。
  • never:永不出现的值——死循环、抛错函数;也用于穷尽检查与收窄兜底。

十一、Interface 与 Type 的取舍

  • 通用语法:interface InterfaceName { property: Type; method(...): ReturnType; } 与 type TypeName = { ... }; 结构等价。
  • 基础类型:number、boolean、string[]、元组皆可。
  • 对象与接口:内联对象类型、接口组合。
  • 联合与交集:type 用 |/& 自由组合;interface 不能原生表达交集。
  • 声明合并(augmentation):同名 interface 自动合并(interface A { x: string } + interface A { y: string } 合并为含 x、y 的单一接口),type 不支持。
  • 扩展:interface 用 extends(不可扩展联合等复杂类型);type 用 &。
  • 结论:需要声明合并或面向对象扩展时用 interface,需要联合/交集/复杂映射时用 type。

十二、内置类型、常用 JS 对象与重载

内置基础类型清单:number、string、boolean、null、undefined、symbol、bigint、any、void、never。常见 JS 内置对象:Function、Object、Boolean、Error、Number、BigInt、Math、Date、String、RegExp、Array、Map、Set、Promise、Intl(详细参考 MDN)。

函数重载:同一函数名声明多个签名 + 一个兼容实现:

function sayHi(name: string): string;
function sayHi(names: string[]): string[];
function sayHi(name: unknown): unknown {
    if (typeof name === 'string') return `Hi, ${name}!`;
    if (Array.isArray(name)) return name.map(n => `Hi, ${n}!`);
    throw new Error('Invalid value');
}

类方法同样支持重载(overload signature + implementation)。合并与扩展:接口同名合并;interface 通过 extends 继承。Type vs Interface 差异(声明合并、扩展语法、联合/交集能力)见上节。

十三、Class 深入

  • 通用语法:class Person { private name: string; constructor(...) {...} public sayHi(): void {...} },new Person('John Doe', 25) 实例化。
  • 构造器:初始化属性;可重载(多个签名 + 单个实现,用可选参数实现兼容,如 constructor(name?: string, age?: number))。
  • private/protected 构造器:private 用于 singleton 或工厂;protected 阻止直接实例化、允许子类 super()。
  • 访问修饰符:private(仅类内)、protected(类内+子类)、public(任意)。
  • get/set:get myProperty() / set myProperty(value) 封装状态并加逻辑。
  • auto-accessor(TS 4.9):accessor name: string; 自动展开为私有后备字段 + getter/setter。
  • this:类方法/构造器内指向当前实例。
  • 参数属性(Parameter Properties):构造器参数加 private/public 自动声明并初始化对应属性。
  • 抽象类:abstract class Animal { abstract makeSound(): void; },子类必须实现抽象方法。
  • 泛型类:class Container<T> { getItem(): T {...} }。
  • 装饰器(TS 5+,ES6 目标):class/property/method/getter-setter 装饰器 + 装饰器元数据;常见用途:属性追踪、方法日志、运行时校验、序列化、鉴权、错误防护。TS 5 的装饰器不允许装饰参数。
  • 继承:extends 单继承 + implements 多接口;class FlyingFish implements Flyable, Swimmable。
  • 静态成员:static memberCount: number = 0; 通过类名访问。
  • 属性初始化:内联默认值、构造器内赋值、构造器参数属性三种方式。
  • 方法重载:同方法多签名,按实参类型分发。

十四、Generics 与类型系统进阶

  • 泛型类型/函数:function identity<T>(arg: T): T;<T,> 尾逗号用于 .tsx 歧义消除;ReadonlyArray<T> 等内置泛型。
  • 泛型类:见上节 Container<T>。
  • 泛型约束:const printLen = <T extends { length: number }>(value: T): void => ...;高阶函数泛型推断(TS 3.4 RC,pointfree 安全组合)。
  • 泛型上下文窄化:function process<T>(value: T) 内按 typeof 分支收窄。

擦除的结构类型:对象只需在结构上满足接口即可使用,无需显式关联(log(obj) 合法)。Namespace:export namespace MyNamespace { export interface MyInterface1 {...} } 组织代码、防命名冲突。Symbol:Symbol('key') 唯一不可变,可作对象键与不可枚举属性。Triple-Slash 指令:/// <reference path="..." /> 引用声明文件、/// <amd|commonjs|...> 指定模块格式、/// <strict|noImplicitAny|...> 开启编译选项。

十五、Utility Types 速查表

Utility 作用 示例
Awaited<T> 递归解包 Promise Awaited<Promise<string>> → string
Partial<T> 全部属性可选 { name?: string; age?: number }
Required<T> 全部属性必填 { name: string; age: number }
Readonly<T> 全部属性只读 赋值报错
Record<K, T> K 为键、T 为值的对象 Record<string, Product>
Pick<T, K> 选取指定属性 Pick<Product, 'price'>
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> 构造器参数类型 [name: string, age: number]
ReturnType<T> 函数返回类型 number
InstanceType<T> 类实例类型 InstanceType<typeof Person>
ThisParameterType<T> 提取 this 参数类型 Person
OmitThisParameter<T> 移除 this 参数 () => string
ThisType<T> 标记上下文 this 类型 对象方法内 this.log(...) 合法
Uppercase/Lowercase/Capitalize/Uncapitalize<T> 字符串大小写变换 "ABC" / "abc" / "Abc" / "abc"
NoInfer<T> 阻止泛型自动推断 fn2(['a','b'], 'c') 报错,强制以 'a'|'b' 为准

十六、其他实用主题

  • 错误处理:try-catch-finally;按 error instanceof TypeError/RangeError 分流;自定义错误类 class CustomError extends Error。
  • Mixin 类:通过 interface 声明合并 + applyMixins 复制 prototype 描述符组合行为。
  • 异步特性:Promise、async/await、Fetch、Web Workers、WebSocket 等受良好支持。
  • Iterator/Generator:自定义 [Symbol.iterator] 实现 Iterable;function* + yield 简化迭代器;支持 async iterator/generator。
  • JSDoc / TsDocs:@param {number} 注解帮助 JS 推断;TS 3.7+ 可从 JSDoc 生成 .d.ts。
  • @types:npm install --save-dev @types/lodash 安装社区类型定义。
  • JSX:jsx: "preserve"(保留 JSX 交 Babel)或 "react"(React.createElement)。
  • ES6 模块配置示例:
{
  "compilerOptions": {
    "target": "es6",
    "module": "es6",
    "moduleResolution": "node",
    "sourceMap": true,
    "outDir": "dist"
  },
  "include": ["src"]
}
  • ES7 幂运算:**(target ≥ es2016)。for-await-of:异步迭代(target es2018)。new.target:判断是否经 new 调用。动态导入:await import('./widget') 条件/懒加载。tsc --watch:文件变更自动重编译(4.9 起优先事件驱动,必要时回退轮询)。
  • 非空断言:person!.name 跳过 null/undefined 检查。默认参数:function greet(name: string = 'Anonymous')。可选链:person.address?.city 安全访问。空值合并:?? 仅在左侧为 null/undefined 时取右值。
  • 模板字面量类型:${Department}-${Language}-id 生成联合。递归类型:type ListNode<T> = { data: T; next: ListNode<T> | undefined };递归条件类型如 Flatten<T> 展平嵌套数组。
  • Node ESM:"module": "nodenext";.mts→.mjs、.cts→.cjs;package.json "type": "module"。
{
  "compilerOptions": {
    "module": "nodenext",
    "outDir": "./lib",
    "declaration": true
  }
}
  • 断言函数(Assertion Functions):asserts value is number,失败即抛错;与返回布尔、用于收窄的 type guard 互补。
  • 可变元组(Variadic Tuple,TS 4.0):type Bar<T extends unknown[]> = [boolean, ...T, number];rest 元素可在任意位置、spread 可为泛型(如泛型 concat 返回 [...T, ...U])。
  • Boxed 类型:string→String、number→Number 等 wrapper 对象;应始终优先使用 primitive。
  • 协变与逆变:数组协变(不完全安全);函数参数在 strictFunctionTypes 下逆变、否则双变;TS 4.7+ 可用 out/in 显式标注 variance。
  • 模板字符串模式索引签名(TS 4.4+):[key: `key-${string}`]: number 与 symbol 索引共存。
  • satisfies 操作符:既验证结构符合类型、又保留字面量精确推断(user3.attributes?.map(...) 正确推断为 string[])。
  • 类型专用导入/导出:import type { House } from './house.ts'、export type { T },减小 bundle;不依赖 allowImportingTsExtensions。
  • using / await using(显式资源管理,TS 5.2):块级不可变绑定,退出作用域时调用 Symbol.dispose/Symbol.asyncDispose;需 target es2022、lib 含 esnext.disposable,并 polyfill Symbol.dispose 等(本书自身工具链即如此配置,见 tools/tsconfig.json 的 lib 字段);SuppressedError 保留被掩盖的异常信息;可用于 for/for-of/switch 等语句。
  • Import Attributes(TS 5.3):import config from './config.json' with { type: 'json' },动态导入用 { with: { type: 'json' } }。
  • 正则语法检查(TS 5.5.4+):编译期校验 regex literal(如非法 backreference),不检查 new RegExp("...")。
  • import defer:仅支持 import defer * as name from "module",直到实际访问 export 才执行模块,避免无谓副作用。

十七、下载、在线阅读与更多资源

  • 英文版 EPUB/PDF 可从 downloads/ 目录获取(typescript-book.epub、typescript-book.pdf);在线版本与多语言网站内容(含泰文 th-th 章节)位于 website/src/content/docs/。
  • 书籍覆盖 TypeScript 7.0;仓库还提供了配套的书籍构建工具链(tools/),包括 tsconfig.json、config.ts(含代码块校验正则 CODE_BLOCK_TS_REGEX)、make-books.sh、verify_codeblocks.py 等,可作为实际工程中类型配置、内容校验与自动化的参考实现。

结语

从语言根基到类型系统的集合论视角,从 tsconfig 的每个开关到 Utility Types 的全景速查,再到 using、import attributes、import defer 等最新特性,《The Concise TypeScript Book》以"既全面又精炼"的方式覆盖了 TypeScript 7.0 的完整面貌。本文结合仓库中 tools/tsconfig.json、website/tsconfig.json 等真实配置,给出了可直接落地的工程示例——无论是新手入门还是老手查漏补缺,都可按章节逐步对照官方书籍源码(website/src/content/docs/book/)深入实践。

登录后查看全文
typescript-book