第一章：类型世界的召唤——初识TypeScript类型系统

图书馆的旧书区总是弥漫着灰尘与旧纸张混合的奇特气息，但那天下午，小码闻到的却是一股淡淡的、像是雨后青草般的清香。循着香气，他在最偏僻的书架底层发现了一本没有书名的古籍，封面是深邃的蓝色，上面流淌着银色的纹路，那些纹路……竟在缓缓移动！小码的好奇心战胜了谨慎，他轻轻翻开第一页，只见泛黄的纸页上写着几个发光的大字：“TypeScript 类型系统入门手册”。还没等他细看，书页突然爆发出刺目的光芒，整个图书馆旋转起来，接着他感觉自己的身体被一股无形的力量吸入书中，像一片落叶坠入深潭，失去了所有重量。

当小码再次睁开眼睛时，他发现自己站在一个完全由代码和类型构成的世界里。天空是淡蓝色的，像是被类型注解修饰过的字符串；脚下的土地坚实而规则，仿佛由严格的对象类型砌成；远处，山峦的轮廓清晰分明，宛如一个个定义完整的接口。空气中漂浮着各种发光的符号：`string`、`number`、`boolean`像基础的光点，`interface`和`type`则如同建筑蓝图般缓缓旋转。小码惊讶地发现，自己能读懂这些符号——它们不再是抽象的编程概念，而是这个世界的“物理法则”。

“欢迎来到类型迷宫，年轻的程序员。”一个温和的声音响起。小码转身，看见一位身着长袍的老者，袍子上绣满了类型的符号。老者的眼睛清澈如初生的`boolean`值，非真即假，不含一丝模糊。

“这里是……哪里？”小码问，声音里带着一丝颤抖。

“这里是TypeScript类型系统的具象化世界，”老者微笑着说，“每个程序员在编写类型安全代码时，都会与这里产生连接。你因为触碰了手册，所以被召唤而来。想要回去，就必须通过迷宫的考验，掌握类型系统的核心法则。”

“考验？什么考验？”

老者指向远处一座巨大的石门，门上刻着复杂的符号：“穿过迷宫，找到‘类型之心’。但小心，迷宫里栖息着‘类型错误’怪兽，它们会攻击任何类型不一致的地方。只有正确运用类型系统，才能保护自己。”

正说着，石门突然轰然打开，一股冷风扑面而来。小码看到门后是一条条分岔的道路，每条路上都闪烁着不同的光芒。老者递给他一枚发光的符石：“这是你的‘类型注解护符’，它能帮助你看清事物的本质类型。现在，出发吧。”

小码深吸一口气，踏入了第一条道路。脚下的地面立刻变得柔软，像是踩在`string`类型的棉花上。他向前走了几步，突然，前方的地面裂开，一个怪物从裂缝中跳出！

那怪物长得像一团扭曲的代码，身体不断在`string`和`number`之间变换，发出刺耳的尖叫：“我是类型错误！你用了错误的数据类型！”怪物伸出爪子，抓向小码的手臂。

千钧一发之际，小码本能地举起护符，护符发出柔和的光芒，在他面前形成一道屏障。怪物的爪子撞在屏障上，发出“滋滋”的声响，无法前进分毫。

“记住！”老者的声音从远处传来，“类型错误怪兽攻击的是类型不一致的地方！用类型注解明确你的意图，它们就无法入侵！”

小码定了定神，仔细观察怪物。他发现怪物的身体确实在`string`和`number`之间不稳定地闪烁——这正是一种典型的类型错误：期望一个类型，却得到了另一个。

“我……我需要声明类型！”小码想起手册上的内容。他集中精神，想象自己在写代码：

```typescript let userAge: number = "十五"; // 这里有问题！ ```

刚想到这里，怪物突然痛苦地嚎叫起来，身体开始崩解。原来，小码的意识中明确指出了错误：`userAge`应该是`number`类型，但他赋了一个`string`值。这个认知本身就是一种“类型检查”，让怪物无处藏身。

“原来如此！”小码明白了，“类型注解就像是一面盾牌，提前告诉编译器（或者说这个世界的法则）我期望什么类型。如果实际值与期望不符，错误就会在‘编译时’暴露，而不是等到运行时才崩溃！”

怪物彻底消散，化作点点星光。小码的护符微微发烫，似乎吸收了什么能量。他继续前进，来到一个广阔的原野。原野上矗立着各种奇特的“建筑”：

有些建筑是简单的立方体，表面刻着`string`、`number`、`boolean`的符号——这些是原始类型，世界的基本构成元素。

有些建筑是复杂的结构，有门窗、楼层，墙上挂着`interface`或`type`的牌子——这些是对象类型，定义了更复杂的形状。

小码还看到三条道路在面前交汇，每条路上有不同的标志：一条写着`"成功"`，一条写着`"进行中"`，一条写着`"失败"`。这是联合类型，表示“这些类型中的任何一个”。

而在另一个方向，两座建筑正在缓缓融合，它们的特征叠加在一起，形成了一座更宏伟的宫殿——那是交叉类型，结合了多个类型的所有特性。

“这些就是类型系统的四大支柱，”老者的声音再次响起，“掌握它们，你就能在迷宫中自由穿行。”

小码点点头，开始探索第一个区域：原始类型世界。

---

原始类型：世界的基石

原始类型区域像是一片宁静的田园，每一种类型都是一株独特的“植物”或“矿石”，散发着柔和的光芒。

小码最先遇到的是`string`之树。这棵树高约三米，树干笔直，树叶是细长的银色纸条，每条纸条上都写着一个字符。当风吹过，树叶沙沙作响，拼凑出各种单词和句子。小码伸手触碰一片树叶，指尖传来温暖的触感，脑海中浮现出“你好，世界！”的字样。

“`string`代表文本序列，”小码喃喃自语，“在TypeScript中，用双引号或单引号包裹的字符集合就是string。”

他继续向前，看见一座`number`矿山。矿山不高，但源源不断地涌出晶莹的矿石，每块矿石都刻着数字：整数如`42`、`-7`，浮点数如`3.14`、`-0.001`。矿石触手冰凉，重量感真实。

“`number`包含所有数值，不分整数浮点数，”小码思考着，“TypeScript没有`int`或`float`的区分，统一用`number`。”

不远处，一池清泉吸引了他的注意。泉水清澈见底，水面平静如镜，但每当小码靠近，水面就会根据他的接近程度显示`true`或`false`。这是`boolean`之池，只有两个状态：真或假，非此即彼。

“`boolean`是最简单的类型，只有`true`和`false`两个值，”小码点头，“就像开关，要么开要么关。”

除了这三种常见类型，小码还发现了其他原始类型：

`null`是一片虚无的虚空，没有任何特征，像一个空荡荡的盒子。

`undefined`则像一层薄雾，模糊不清，表示“存在但未定义”。

`symbol`是一面面发光的小镜子，每面镜子都反射出独一无二的图案，代表唯一标识符。

`bigint`则是一座巨大的石柱，上面刻着天文数字，远超普通`number`的范围。

“这些原始类型是类型系统的原子，”老者突然出现在小码身边，“它们不可再分，是所有复杂类型的构建块。就像化学中的元素周期表，掌握它们，就能组合出无限可能。”

小码正想询问如何在实际代码中使用，突然，地面开始震动。几个`类型错误`怪兽从地底钻出，它们的身体这次呈现出更复杂的状态：一部分是`string`的流动形态，一部分是`number`的固体形态，还有一部分是`boolean`的二元闪烁。

“小心！”老者喊道，“这是多重类型不一致！它们同时违反了多种类型规则！”

小码慌乱中举起护符，但护符的光芒变得不稳定。他意识到，仅仅知道概念还不够，必须学会如何声明和使用这些类型。

他闭上眼睛，回忆手册中的示例：

```typescript // 声明一个字符串变量 let greeting: string = "Hello, TypeScript!";

// 声明一个数字变量 let score: number = 100;

// 声明一个布尔变量 let isPassed: boolean = true;

// 也可以不显式声明，让TypeScript推断 let inferredString = "自动推断为string"; let inferredNumber = 42; // 自动推断为number ```

随着这些代码在小码脑海中浮现，护符重新稳定下来，光芒甚至比以前更亮。他明白，类型注解（`变量: 类型`）就是告诉这个世界“这个值应该是什么类型”。当声明与实际情况不符时，错误就会暴露。

小码集中精神，对最近的一个怪物“下达指令”：

```typescript let monsterPart: string = 123; // 错误：将number赋给string ```

这个“声明”在迷宫中形成了实质性的规则。怪物痛苦地扭曲，因为它的一部分被强制要求是`string`，但它实际是`number`。 inconsistency（不一致）让它无法维持存在。

“我明白了！”小码兴奋地说，“类型注解就像给变量贴上标签。如果标签内容和实际物品不符，TypeScript就会报错，阻止程序继续运行——就像现在，怪物被标签矛盾摧毁！”

老者赞许地点头：“正确。原始类型是基础，但单独使用它们能力有限。要构建真正的程序，你需要将它们组合成更复杂的结构。跟我来，看看对象类型区域。”

---

对象类型：构建复杂世界

离开原始类型田园，小码来到一片建筑群。这里的建筑不再是自然形态，而是精心设计的结构。

第一座建筑是一个简单的矩形小屋，墙上写着：

```typescript interface Point { x: number; y: number; } ```

小屋有两个窗户，分别标记着`x`和`y`，每个窗户里都透出`number`的光芒。小码推门进去，发现内部空间严格按照定义：`x`坐标在左边，`y`坐标在右边，两者都是数字。

“这是接口（interface），”老者解释，“它定义了一个对象的形状——有哪些属性，每个属性是什么类型。就像建筑的蓝图，规定了房子必须有什么房间，每个房间的用途。”

小码又走到另一座建筑，样式相似，但定义方式不同：

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

“这是类型别名（type alias），用`type`关键字定义。它和interface在定义对象形状时几乎一样，但`type`更灵活，可以定义联合类型、交叉类型等更多形式。”

小码注意到，两座建筑内部结构完全相同，但interface像“合同”，可以扩展；type像“标签”，更灵活。

“在实际开发中，什么时候用interface，什么时候用type呢？”小码问。

“好问题！”老者指向远处，“看那座更大的建筑。”

那是一座图书馆式的建筑，墙上写着：

```typescript interface Animal { name: string; move(): void; }

interface Bird extends Animal { fly(): void; }

interface Fish extends Animal { swim(): void; } ```

“interface支持继承（extends），可以基于现有接口创建新接口，添加或修改属性。这是构建层次化类型体系的强大工具。”

接着，老者又指向另一座建筑：

```typescript type Status = "idle" | "running" | "error"; type Callback = (data: string) => void; type Maybe<T> = T | null; ```

“而`type`可以定义联合类型、函数类型、泛型等。当需要这些高级特性时，通常使用type。”

小码正在消化这些信息，突然，一阵狂风袭来！几个新型的`类型错误`怪兽出现了。这些怪兽不再是简单的类型混合，而是结构不匹配——它们试图伪装成合法的对象，但内部属性缺失或类型错误。

一只怪兽长着`x`窗户，但`y`窗户却透出`string`的光；另一只有`name`属性，但`move`方法却缺失了。

“这些是对象类型错误，”老者喊道，“它们违反了接口定义的形状！用你的护符检查对象的‘结构’！”

小码举起护符，护符投射出一道光束，扫描怪物：

```typescript // 期望的结构 interface Hero { name: string; level: number; skills: string[]; }

// 怪物的实际结构（错误） let fakeHero = { name: "小码", level: "十五", // 错误：应该是number，却是string skills: ["打字", "思考"] }; ```

光束照在怪物身上，立刻显现出错误：`level`属性应该是`number`，但实际是`string`。怪物发出惨叫，开始瓦解。

“我懂了！”小码说，“对象类型定义了‘必须有什么属性，每个属性什么类型’。如果实际对象缺少属性，或者属性类型不对，就是类型错误！”

老者微笑：“不仅如此，还有更微妙的情况。看那边。”

小码顺着他指的方向看去，只见一座建筑前站着一个人影，那人影试图进入建筑，但每次快到门口就被弹开。

“那是多余属性检查，”老者解释，“当你有一个对象字面量直接赋值给变量或参数时，TypeScript会检查对象是否包含目标类型没有定义的额外属性。”

示例在小码脑海中浮现：

```typescript interface User { id: number; name: string; }

// 这个对象多了一个'age'属性 let newUser = { id: 1, name: "小码", age: 15 // 错误：User接口没有age属性 };

// 赋值时会报错 let user: User = newUser; // 错误：对象字面量可能有未定义的属性'age' ```

“但为什么有时又不报错呢？”小码问。

“好观察！”老者点头，“当对象先声明再赋值，或者通过变量传递时，多余属性检查会放宽。这是TypeScript的设计，避免过于严格。但作为程序员，你应该保持警惕，确保对象形状与接口严格匹配。”

小码尝试用护符“修复”那个被弹开的人影：

```typescript // 正确的对象 let validUser = { id: 1, name: "小码" // 没有多余属性 };

let user: User = validUser; // 正确 ```

人影顺利进入了建筑，化作一道光融入其中。

“太棒了！”小码欢呼，“对象类型让我能定义复杂的数据结构，而类型检查确保它们的使用方式正确。”

“没错，”老者说，“但对象类型还有更强大的用法。看这里——”

他指向一片特殊的区域，那里漂浮着许多可选的属性：

```typescript interface OptionalHero { name: string; level?: number; // 问号表示可选属性 skills?: string[]; } ```

“属性名后加`?`表示可选属性，该属性可以存在也可以不存在。”

小码还看到一些属性有默认值：

```typescript interface Config { timeout: number; retries: number = 3; // 默认值 url: string; } ```

“以及只读属性，”老者继续，“用`readonly`修饰，防止被修改。”

```typescript interface ImmutablePoint { readonly x: number; readonly y: number; } ```

“这些特性让对象类型更灵活、更安全，”小码总结，“我可以用interface或type定义数据形状，TypeScript会检查所有使用点，确保一致性。”

“正是如此，”老者满意地点头，“现在，去试试联合类型区域吧。那里更……变化莫测。”

---

联合类型：岔路与选择

联合类型区域像是一片广阔的岔路口迷宫，每条路都代表一个可能的类型。

入口处，小码看到一块石碑，上面刻着：

```typescript type Status = "idle" | "running" | "success" | "failed"; ```

石碑前有四个按钮，分别标记着这四个状态。小码按下“idle”，石碑发出绿光；按下“running”，也亮起；但当他试图按下“paused”时，石碑拒绝响应，发出红色警告。

“这就是字面量联合类型，”老者解释，“它限制值只能是这几个特定的字符串之一。这比普通string类型更安全，因为你知道确切有哪些可能值。”

小码继续前进，来到一个三岔路口。每个路口上方都挂着牌子：

• 左边：`string`
• 中间：`number`
• 右边：`boolean`

“这是基本类型联合，”老者说，“值可以是其中任何一种类型。”

小码看到路上有行人在走，每个行人身上都带着一个标签，显示他们的当前类型。有人是`string`（背着字母背包），有人是`number`（扛着数字箱子），有人是`boolean`（头上顶着true/false旗帜）。

“但这样不是太模糊了吗？”小码问，“如果我知道一个值可能是string或number，使用时还得不断检查实际类型。”

“敏锐的观察！”老者微笑，“这就是为什么TypeScript提供了类型守卫。”

他指向路口中央，那里有一座小亭子，亭子里有台机器：

```typescript function processInput(input: string | number) { if (typeof input === "string") { // 这里input被收窄为string类型 console.log(input.toUpperCase()); } else { // 这里input被收窄为number类型 console.log(input.toFixed(2)); } } ```

“`typeof`操作符就是类型守卫之一，”老者解释，“在条件分支中，TypeScript能自动‘收窄’联合类型，让你在特定分支里使用该类型特有的方法。”

小码尝试理解：当`input`是`string | number`时，我不能直接调用`toUpperCase()`（那是string的方法）或`toFixed()`（那是number的方法），因为编译器不知道当前是哪种类型。但通过`typeof`检查，TypeScript就能在相应分支中知道确切类型。

“还有其他守卫方式吗？”小码问。

“当然。看这个例子——”

```typescript