第 3 章:基础类型与类型推断
大部分类型不用你手写——TypeScript 会自己推断。你真正要做的,是知道它推断得对不对,然后在关键处补上那一笔。
学习目标
- 掌握原始类型、数组、元组的写法,知道各自适合什么场景
- 理解类型推断的规则,知道什么时候必须手写标注
- 分清
any、unknown、never三个"边缘类型"的使用场合 - 会用字面量类型、
as const、satisfies拿到更精确的类型 - 知道
null/undefined在strict模式下怎么处理
3.1 原始类型
TypeScript 里的原始类型和 JavaScript 的 typeof 结果基本对应:
let name: string = '陌阡'
let age: number = 42
let active: boolean = true
let big: bigint = 9007199254740993n
let sym: symbol = Symbol('id')
let nothing: null = null
let missing: undefined = undefined几个容易踩的点:
- 没有
int/float之分,所有数字都是number,包括整数、小数、NaN、Infinity。 null和undefined各自是独立类型。在strictNullChecks下,它们不能赋给string等其他类型(3.6 节讲)。- 不要写
String、Number、Boolean(大写开头)。那是包装对象类型,几乎没人用,写了会遇到'abc' is not assignable to type 'String'这类怪报错。永远用小写。
3.2 类型推断:能少写就少写
TypeScript 会从赋值和上下文推断类型,绝大多数局部变量不需要标注:
let count = 0 // number
let title = '你好' // string
let tags = ['ai', 'ts'] // string[]
const pi = 3.14 // 字面量类型 3.14
function double(n: number) {
return n * 2 // 返回值推断为 number
}注意 let 和 const 的差别:
let a = 'hello' // string(可能被重新赋值成别的字符串)
const b = 'hello' // 'hello'(字面量类型,精确到值)
let c = 'hello' as const // 'hello'let 推断成宽泛的 string,const 推断成精确的 'hello'。这不是玄学,而是编译器在保守地判断"这个变量还可能变成别的值吗"。
什么时候必须手写
| 场景 | 为什么 |
|---|---|
| 函数参数 | 参数没有初始值,推断不出来 |
空数组 const list = [] | 元素类型待定(演进数组),无法推断时 strict 下报隐式 any |
| 声明和赋值分开 | let user; 会推断成 any(strict 下报错) |
| 函数返回值是公共 API | 显式标注相当于锁定契约,防止实现改动悄悄改变对外类型 |
| 变量要装多种可能的值 | 需要联合类型(第 6 章)来明确描述 |
空数组这个坑很典型:
const list = [] // 元素类型还没定,是一个"正在演进"的 any[]
list.push('a') // 这一步把它演进成 string[]
const list2: string[] = [] // 推荐:一开始就说清元素类型const list = [] 不是 never[],而是一个演进的数组类型(evolving array):编译器会根据后续的 push 推断元素类型。如果元素类型始终确定不了(比如直接把空数组当参数传给函数),noImplicitAny 下会报错:
Variable 'list' implicitly has type 'any[]' in some locations where its type cannot be determined.所以在 strict 模式下,空数组最稳妥的写法是一开始就标注:const list: string[] = []。
3.3 数组与元组
数组:同类型元素的集合
let names: string[] = ['阿吉', '小麦']
let scores: Array<number> = [90, 85] // 等价写法,泛型形式
let matrix: number[][] = [[1, 2], [3, 4]]string[] 和 Array<string> 完全等价,日常用前者,遇到复杂嵌套时泛型写法更好读。
只读数组用 readonly:
const colors: readonly string[] = ['red', 'green']
colors.push('blue') // 报错:readonly 数组没有 push元组:位置和类型都固定的数组
普通数组只知道"元素都是 string",元组还知道"第一个是 string,第二个是 number"。
let point: [number, number] = [3, 4]
let entry: [string, number] = ['apple', 12]
// 可选元素
let range: [number, number?] = [0]
range = [0, 100]
// 带标签的元组(可读性更好)
let rgb: [r: number, g: number, b: number] = [255, 128, 0]元组最常见的用途是函数返回多个值:
function minMax(nums: number[]): [number, number] {
return [Math.min(...nums), Math.max(...nums)]
}
const [min, max] = minMax([3, 1, 4, 1, 5])经验法则:元素类型相同用数组,位置有明确含义才用元组。 超过 3 个元素的元组就该考虑换成对象,
[string, number, boolean, Date]这种读代码时没人记得住顺序。
元组有长度上限吗?没有,但越长的元组越难维护。TS 允许 [string, ...number[]] 这种"开头固定 + 剩余同类型"的写法,常用来描述 ['error', ...details] 结构。
3.4 any、unknown、never:三个容易混的类型
这三个类型看起来都"不是具体类型",但语义完全不同。先看它们的赋值方向,这是分清三者的关键:
any 是双向都通,所以最危险;unknown 是必须先证明再使用,所以最安全;never 谁也进不来,所以能用来做兜底。
any:关掉检查
let data: any = JSON.parse('{"a":1}')
data.whatever.deep.field // 不报错
data() // 不报错
data + 1 // 不报错any 等于告诉编译器"别管我"。它会沿着赋值和调用往下传染,最终整条链路都失去检查。
用它的唯一合理场景:迁移老代码时的临时缺口。用完要尽快补上真实类型,并打开 noImplicitAny 防止它悄悄出现。
unknown:安全的 any
let input: unknown = JSON.parse('{"a":1}')
input.a // 报错:Object is of type 'unknown'
input() // 报错
if (typeof input === 'object' && input !== null) {
// 收窄之后才能用
}unknown 表示"我不知道是什么",但必须先收窄才能使用。它是所有外部数据的正确起点:fetch 响应、JSON.parse、catch 捕获的错误(strict 下 catch 变量就是 unknown)。
try {
risky()
} catch (err) {
if (err instanceof Error) {
console.log(err.message) // 收窄后才能安全访问
}
}any 和 unknown 的选择规则很简单:能用 unknown 就别用 any。前者逼你做检查,后者让你忘记检查。
never:不可能的值
never 表示一个值永远不会出现。它出现在两个地方:
// 1. 永远抛异常或死循环的函数,返回值是 never
function fail(msg: string): never {
throw new Error(msg)
}
// 2. 收窄到没有任何剩余可能(第 6 章会用它做穷尽检查)
function assertNever(x: never): never {
throw new Error(`未处理的情况:${String(x)}`)
}日常写代码几乎不用主动标 never,但理解它能帮你看懂第 6 章的穷尽检查。
一张表分清
| 类型 | 含义 | 能赋值给谁 | 谁(什么)能赋值给它 | 典型场景 |
|---|---|---|---|---|
any | 任意类型,关闭检查 | 任何类型 | 任何值 | 临时迁移、老代码 |
unknown | 任意类型,但必须先收窄 | 只能赋给 any / unknown | 任何值 | 外部输入、catch |
never | 空类型,不存在任何值 | 任何类型 | 没有任何值能赋给它 | 抛异常的返回值、穷尽检查 |
any是"双向都通",所以最危险;unknown是"进得来出不去",所以最安全;never是"谁也进不来",所以能做兜底。
3.5 字面量类型与 as const
字符串、数字、布尔值可以作为类型:
let direction: 'left' | 'right' = 'left'
direction = 'up' // 报错:只能是 left 或 right这种写法是 TypeScript 里最实用的技巧之一:用字面量联合代替枚举(第 8 章详述)。
对象和数组的字面量要用 as const 才能锁死:
const config = {
level: 'debug',
retries: 3
}
// 推断为 { level: string; retries: number }
const config2 = {
level: 'debug',
retries: 3
} as const
// 推断为 { readonly level: "debug"; readonly retries: 3 }as const 做三件事:所有属性变 readonly、字符串变字面量类型、数组变 readonly 元组。
const ROLES = ['admin', 'editor', 'viewer'] as const
type Role = typeof ROLES[number] // 'admin' | 'editor' | 'viewer'
typeof ROLES[number]的意思是"取这个数组元素类型的联合"。这行代码是前后端共享常量时最常用的写法,第 11 章会再讲typeof和索引访问。
satisfies:既校验又保留精确推断
as const 的问题是它太死了,as 断言又太松。TS 4.9 引入的 satisfies 正好补中间这块:校验形状的同时,保留值自身的推断结果。
type Config = Record<string, string | number>
const config = {
level: 'debug',
retries: 3
} satisfies Config
// 校验通过,config 的类型是 { level: string; retries: number }注意一个细节:satisfies 不会阻止字符串字面量宽化。 上面 config.level 的类型是 string,不是 'debug'。要连字面量一起保留,得两个一起用:
const config2 = {
level: 'debug',
retries: 3
} as const satisfies Config
// config2.level: 'debug',且整体只读as const satisfies 是配置对象最精确的写法:既校验了"符合 Config",又没丢失字面量和只读性。
satisfies 真正擅长的场景是"要符合约束,但每个键还想要自己的精确类型"——路由表、主题色、动作映射这类对象:
3.6 null、undefined 与严格空值检查
strictNullChecks 开启后:
let name: string = null // 报错
let age: number = undefined // 报错
let nickname: string | null = null // 正确:把 null 写进类型这看起来麻烦,但它逼你把"可能没有值"这件事写在类型里,而不是靠注释或者口头约定。处理方式有三种:
// 1. 可选链:链路上任何一环是 null/undefined 就返回 undefined
const city = user?.address?.city
// 2. 空值合并:左边是 null/undefined 才取右边(注意不是 ||)
const limit = input.limit ?? 10?? 和 || 的区别必须记住:
| 写法 | 左侧是 0 或 '' 时 | 适用 |
|---|---|---|
a ?? b | 保留 0 / '' | 数字、字符串默认值(推荐) |
a || b | 被替换成 b | 只关心真假值的布尔场景 |
const count = input.count ?? 10 // 传 0 时得到 0,正确
const count2 = input.count || 10 // 传 0 时得到 10,可能是 bug// 3. 显式判断,收窄类型
if (user != null) {
console.log(user.name) // 这里 user 已经不是 null
}用
!= null可以同时排除null和undefined,比写!== null && !== undefined简洁,这是社区通用写法。
3.7 类型断言:as、! 和它们的代价
断言是"我比你懂,按我说的算",它不做任何运行时检查。
const el = document.querySelector('#app') as HTMLDivElement
el.innerHTML = ''
// 非空断言:告诉编译器"这里不可能是 null/undefined"
const input = document.querySelector<HTMLInputElement>('#name')!
input.value断言的代价:如果断错了,编译器不会救你,运行时照样崩。
const value = JSON.parse('null') as { name: string }
value.name // 运行时 TypeError: Cannot read properties of null什么时候可以用:
| 可以 | 不可以 |
|---|---|
| 你比编译器多知道确定的 DOM 结构 | 为了消掉红线随手 as any |
| 第三方库类型写错了,你确知真实类型 | 用断言掩盖自己没想清楚的数据结构 |
| 测试代码里构造非法输入 | 外部数据进来时用断言当校验 |
一个更安全的替代:类型守卫函数 + 运行时检查(第 6 章):
function isUser(value: unknown): value is { name: string } {
return typeof value === 'object' && value !== null && typeof (value as any).name === 'string'
}它既是断言,又真的检查了。
3.8 常见误区
误区一:到处写 : any 图省事。 → 等于把 TS 关掉。想表达"未知"用 unknown,它会逼你在使用前检查。
误区二:以为空数组一定是 never[] 或 any[]。 → 它是演进数组:有 push 就按推入的值推断;无法推断时 strict 下报隐式 any。一开始写 const list: string[] = [] 最省事。
误区三:as 是"转换类型",像 Java 的强制转型。 → 它不转换任何数据,只在编译期改标签。'123' as unknown as number 运行时还是字符串。
误区四:?? 和 || 可以混用。 → 数字和字符串默认值必须用 ??,否则 0 和 '' 会被当成"没值"。
误区五:数组和元组随便选。 → 元组适合"位置有含义且数量少"的场景。一旦超过 3 个元素,改成对象加字段名,可读性高得多。
本章小结
| 要点 | 说明 |
|---|---|
| 原始类型 | string/number/boolean/null/undefined/bigint/symbol,一律小写 |
| 类型推断 | let 推宽、const 推窄;参数、空数组、声明与赋值分离时必须手写 |
| 数组 vs 元组 | 同类元素用数组;位置有意义且短用元组 |
any/unknown/never | any 关检查、unknown 必须先收窄、never 表示不存在 |
| 字面量类型 | 用联合字面量表达有限的取值集合;as const 锁死对象与数组 |
satisfies | 校验形状并保留值自身推断;要保留字面量用 as const satisfies |
| 空值处理 | strictNullChecks 下用 ?.、??、!= null 收窄 |
| 断言 | as / ! 不做运行时检查,能不用就不用 |
下一章预告
有了基础类型,下一步是函数。下一章讲参数怎么标、返回值怎么定、回调函数怎么写类型,以及"函数重载"这个看起来高级但实际很好用的东西。