Skip to content
Lv1TypeScript进度 1 / 14

第 1 章:初识 TypeScript ​

JavaScript 的灵活,是靠"运行时才发现错了"换来的。TypeScript 想做的,是把其中一大半错误提前到写代码的时候。


学习目标 ​

  • 说清 TypeScript 和 JavaScript 到底是什么关系
  • 理解"类型只在编译期存在"这句话的真正含义
  • 知道 tsc 把 .ts 编译成什么,以及哪些语法会留下运行时痕迹
  • 判断一个项目值不值得上 TypeScript,以及它的成本在哪

1.1 一段没有类型的代码,是怎么出事的 ​

先看一段很普通的 JavaScript:

javascript
function calcTotal(price, count) {
  return price * count
}

const total = calcTotal('19.9', 3)
console.log(total) // 59.699999999999996

价格从表单或者接口里取出来,是字符串 '19.9'。* 运算符会把它悄悄转成数字,于是这行"看起来对"的代码跑通了,最后打印出一个带浮点误差的 59.699999999999996。

再换一个更隐蔽的写法:

javascript
function applyDiscount(price, rate) {
  return price - rate
}

applyDiscount('100', 10) // 90
applyDiscount('100', '10') // 90,但这是字符串减法,碰巧对

第二行碰巧也对,因为减法会把字符串转成数字。可如果函数里写的是 price + rate,'100' + 10 就变成 '10010'——不报错,但结果全错。

这类 bug 有一个共同点:代码没有崩,错误往下游传了很远,最后在页面上显示一个离谱的价格,再花两个小时往回查。

JavaScript 是动态类型语言,变量的类型由运行时的值决定。这带来极高的灵活性,也意味着类型错误只能在运行时暴露——而且往往是运气好才暴露。

TypeScript 要解决的,就是这个时间差。


1.2 TypeScript 是 JavaScript 的超集 ​

这句话不是修辞,是可以拆开验证的事实:

  • 任何合法的 JavaScript 代码,改个后缀就是合法的 TypeScript 代码(在默认配置下);
  • TypeScript 在 JavaScript 之上只加了一样东西:类型标注和类型检查;
  • 编译之后,类型标注全部消失,产物就是普通的 JavaScript。
typescript
function calcTotal(price: number, count: number): number {
  return price * count
}

calcTotal('19.9', 3) // 编译期报错:类型"string"的参数不能赋给类型"number"的参数

上面这段代码不会等到运行时才炸,编辑器里 '19.9' 下面就已经画了红线。这就是 TypeScript 的核心价值:把错误发生的时刻,从"用户点下单"提前到"你敲回车"。

TypeScript 由微软在 2012 年发布,最初是为了让大型 JavaScript 项目(尤其是 IDE 里的智能提示)变得可控。今天它已经是前端的事实标准:主流框架、构建工具、组件库基本都用 TS 写,类型声明也随包一起发布。

先看这条链路,后面所有内容都建立在它之上:

类型检查发生在左边,类型擦除发生在右边。 编译产物里一点类型痕迹都不留,这就是下一节要讲的"类型只在编译期存在"。

但要注意:TypeScript 没有自己的运行时。浏览器不认识 .ts 文件,Node 默认也不认识。所有 .ts 都必须先编译(或者用 tsx、esbuild 这类工具即时转换)成 .js 才能执行。


1.3 类型只在编译期存在 ​

这是学 TS 最容易被忽略、也最容易误解的一点。

typescript
let price: number = 19.9

// 编译后(简化示意)
let price = 19.9

: number 被完整地删掉了。运行时你问"这个变量是什么类型",答案是"它就是个数字",没有任何类型元数据可查。

于是会得到一个反直觉的结论:

TypeScript 保证的不是"运行时类型正确",而是"代码在类型上自洽"。

看一个经典例子:

typescript
interface User {
  id: number
  name: string
}

async function fetchUser(): Promise<User> {
  const res = await fetch('/api/user/1')
  return res.json() // 注意这里
}

res.json() 的返回类型是 Promise<any>,赋给 Promise<User> 不会报错——因为 any 可以赋给任何类型。编译通过了,但如果后端真的返回 { "id": "1", "name": null },运行时的 user.id 就是字符串,user.name 就是 null,TS 一点忙都帮不上。

所以有一句必须记住的话:

你以为 TS 做的TS 实际做的
保证接口返回的数据结构正确假设你声明的类型是对的,检查你的代码前后是否自洽
防止运行时崩溃防止"类型上明显不成立"的写法
校验外部数据完全不校验,需要你在边界上自己校验(第 14 章讲 zod)

这个边界在哪里,决定了 TS 能不能真正帮到你。凡是数据从外部进来的地方(接口响应、表单、JSON.parse、环境变量、数据库结果),类型声明都只是你的一厢情愿,必须配上运行时校验。


1.4 编译产物长什么样 ​

写一个最小的 TS 文件:

typescript
// greet.ts
interface Person {
  name: string
}

function greet(person: Person): string {
  return `你好,${person.name}`
}

console.log(greet({ name: '陌阡' }))

用 tsc greet.ts 编译,得到 greet.js:

javascript
"use strict";
function greet(person) {
    return `你好,${person.name}`;
}
console.log(greet({ name: '陌阡' }));

interface 整个消失了,参数上的 : Person 也没了。类型系统在编译结束那一刻就完成了使命。

少数语法例外:下面这些写法不只是类型,还会生成真实的运行时代码。

写法是否生成运行时代码说明
interface / type否纯类型,编译后完全擦除
enum是生成一个对象(第 8 章详述,通常建议用联合类型替代)
namespace是生成包裹函数,现代项目基本不用
构造函数参数属性 constructor(private x: number)是自动生成赋值语句(第 9 章)
装饰器 @Component是生成调用代码,取决于配置

记住这张表,后面遇到"为什么这里编译完多了几行代码"就不会困惑。


1.5 上不上 TypeScript:把账算清楚 ​

收益成本
类型错误在写代码时暴露,不用等用户点出来要写类型,初期代码量增加 20%~40%
编辑器能精确补全、跳转、找引用,读陌生代码快很多要维护 tsconfig,构建链路多一步
重构时改一个字段名,编译器会列出所有要改的地方第三方库缺类型时要自己补声明(第 12 章)
类型即文档,接口契约写在代码里,不用靠注释同步团队得统一规范,否则 any 满天飞,等于白上
大型项目、多人协作收益最大一次性脚本、几十行的小工具,收益有限

判断标准很简单:

  • 代码会活过三个月、会被第二个人读 → 上 TS;
  • 跑一次就丢的脚本、临时验证想法的 demo → JS 更省事。

你不需要全项目一次性迁移。TS 支持渐进式采用:allowJs: true 之后,.js 和 .ts 可以混着放,老文件不动,新文件用 TS,checkJs 还可以只给部分 JS 文件加检查。这是它比很多强类型语言更容易落地的地方。


1.6 和 Python 类型注解、Java 有什么区别 ​

如果你有后端背景,用熟悉的东西类比会快很多。

维度TypeScriptPython 类型注解Java
检查时机编译期(写代码时)运行时可选择检查(mypy 等)编译期 + 运行时
运行时是否存在类型不存在,全部擦除注解对象实际存在(__annotations__)存在(反射可读)
是否强制可配置强弱(strict)完全不强制强制
类型系统能力结构化类型 + 较强的高级类型渐进式,鸭子类型为主名义类型,泛型有擦除
常见心智"给 JS 加类型""给函数加说明""类型是语言核心"

两个关键差异值得单独记:

  1. TS 是结构化类型:两个类型只要"形状一样"就兼容,名字不同也无所谓。Java 里 class A 和 class B 长得再像也不能互传(名义类型)。第 5 章会展开。
  2. TS 的类型可以参与运算:keyof、映射类型、条件类型让类型本身变成可编程的。这是它比 Java 泛型更灵活的地方,也是"类型体操"的来源(第 11 章)。

1.7 三个常见误区 ​

误区一:上了 TS 就不会有运行时 bug 了。 → 类型只约束代码内部的写法。接口返回脏数据、用户输入乱填、JSON.parse 拿到意外结构,TS 全都看不见。边界校验必须在运行时做。

误区二:any 是"先跑起来再说"的万能钥匙。 → any 会关闭这一整条链路的检查,并且往下污染:any 传给别人,别人也变成 any。一个项目里 any 多了,TS 就退化成"带类型的注释"。要临时绕过用 unknown + 收窄,或者写 // @ts-expect-error 并注明原因(第 3 章、第 12 章)。

误区三:TypeScript 是一门新语言,要重新学一遍。 → 语法、运算符、函数、对象、原型链,全都是 JavaScript 那一套。你要新学的只有"类型怎么写"和"报错怎么读"这两件事。写 TS 的时候,你仍然是在写 JS。


本章小结 ​

要点说明
超集关系合法 JS 就是合法 TS,TS 只额外加类型标注与检查
编译期检查错误在写代码时暴露,不等到运行时
类型擦除编译后类型全部消失,运行时查不到任何类型信息
不校验外部数据接口、表单、JSON 的合法性必须运行时自己校验
例外语法enum、namespace、参数属性、装饰器会生成运行时代码
上手成本类型代码量增加,换来重构安全与可读性;小脚本可不上

下一章预告 ​

道理讲完了,先把环境跑起来。下一章装 Node、建一个最小 TS 项目,让 tsc 真正把 .ts 编译成 .js,并逐个解释 tsconfig.json 里最先该开的几个开关。

👉 第 2 章:开发环境与第一个项目

本文阅读--次|全站访问--次|访客--人