Skip to content
Lv1TypeScript进度 3 / 14

第 3 章:基础类型与类型推断 ​

大部分类型不用你手写——TypeScript 会自己推断。你真正要做的,是知道它推断得对不对,然后在关键处补上那一笔。


学习目标 ​

  • 掌握原始类型、数组、元组的写法,知道各自适合什么场景
  • 理解类型推断的规则,知道什么时候必须手写标注
  • 分清 any、unknown、never 三个"边缘类型"的使用场合
  • 会用字面量类型、as const、satisfies 拿到更精确的类型
  • 知道 null / undefined 在 strict 模式下怎么处理

3.1 原始类型 ​

TypeScript 里的原始类型和 JavaScript 的 typeof 结果基本对应:

typescript
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 会从赋值和上下文推断类型,绝大多数局部变量不需要标注:

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 的差别:

typescript
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 章)来明确描述

空数组这个坑很典型:

typescript
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 数组与元组 ​

数组:同类型元素的集合 ​

typescript
let names: string[] = ['阿吉', '小麦']
let scores: Array<number> = [90, 85]     // 等价写法,泛型形式
let matrix: number[][] = [[1, 2], [3, 4]]

string[] 和 Array<string> 完全等价,日常用前者,遇到复杂嵌套时泛型写法更好读。

只读数组用 readonly:

typescript
const colors: readonly string[] = ['red', 'green']
colors.push('blue') // 报错:readonly 数组没有 push

元组:位置和类型都固定的数组 ​

普通数组只知道"元素都是 string",元组还知道"第一个是 string,第二个是 number"。

typescript
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]

元组最常见的用途是函数返回多个值:

typescript
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:关掉检查 ​

typescript
let data: any = JSON.parse('{"a":1}')
data.whatever.deep.field  // 不报错
data()                    // 不报错
data + 1                  // 不报错

any 等于告诉编译器"别管我"。它会沿着赋值和调用往下传染,最终整条链路都失去检查。

用它的唯一合理场景:迁移老代码时的临时缺口。用完要尽快补上真实类型,并打开 noImplicitAny 防止它悄悄出现。

unknown:安全的 any ​

typescript
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)。

typescript
try {
  risky()
} catch (err) {
  if (err instanceof Error) {
    console.log(err.message)  // 收窄后才能安全访问
  }
}

any 和 unknown 的选择规则很简单:能用 unknown 就别用 any。前者逼你做检查,后者让你忘记检查。

never:不可能的值 ​

never 表示一个值永远不会出现。它出现在两个地方:

typescript
// 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 ​

字符串、数字、布尔值可以作为类型:

typescript
let direction: 'left' | 'right' = 'left'
direction = 'up'   // 报错:只能是 left 或 right

这种写法是 TypeScript 里最实用的技巧之一:用字面量联合代替枚举(第 8 章详述)。

对象和数组的字面量要用 as const 才能锁死:

typescript
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 元组。

typescript
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 正好补中间这块:校验形状的同时,保留值自身的推断结果。

typescript
type Config = Record<string, string | number>

const config = {
  level: 'debug',
  retries: 3
} satisfies Config
// 校验通过,config 的类型是 { level: string; retries: number }

注意一个细节:satisfies 不会阻止字符串字面量宽化。 上面 config.level 的类型是 string,不是 'debug'。要连字面量一起保留,得两个一起用:

typescript
const config2 = {
  level: 'debug',
  retries: 3
} as const satisfies Config
// config2.level: 'debug',且整体只读

as const satisfies 是配置对象最精确的写法:既校验了"符合 Config",又没丢失字面量和只读性。

satisfies 真正擅长的场景是"要符合约束,但每个键还想要自己的精确类型"——路由表、主题色、动作映射这类对象:


3.6 null、undefined 与严格空值检查 ​

strictNullChecks 开启后:

typescript
let name: string = null      // 报错
let age: number = undefined  // 报错

let nickname: string | null = null   // 正确:把 null 写进类型

这看起来麻烦,但它逼你把"可能没有值"这件事写在类型里,而不是靠注释或者口头约定。处理方式有三种:

typescript
// 1. 可选链:链路上任何一环是 null/undefined 就返回 undefined
const city = user?.address?.city

// 2. 空值合并:左边是 null/undefined 才取右边(注意不是 ||)
const limit = input.limit ?? 10

?? 和 || 的区别必须记住:

写法左侧是 0 或 '' 时适用
a ?? b保留 0 / ''数字、字符串默认值(推荐)
a || b被替换成 b只关心真假值的布尔场景
typescript
const count = input.count ?? 10   // 传 0 时得到 0,正确
const count2 = input.count || 10  // 传 0 时得到 10,可能是 bug
typescript
// 3. 显式判断,收窄类型
if (user != null) {
  console.log(user.name)  // 这里 user 已经不是 null
}

用 != null 可以同时排除 null 和 undefined,比写 !== null && !== undefined 简洁,这是社区通用写法。


3.7 类型断言:as、! 和它们的代价 ​

断言是"我比你懂,按我说的算",它不做任何运行时检查。

typescript
const el = document.querySelector('#app') as HTMLDivElement
el.innerHTML = ''

// 非空断言:告诉编译器"这里不可能是 null/undefined"
const input = document.querySelector<HTMLInputElement>('#name')!
input.value

断言的代价:如果断错了,编译器不会救你,运行时照样崩。

typescript
const value = JSON.parse('null') as { name: string }
value.name  // 运行时 TypeError: Cannot read properties of null

什么时候可以用:

可以不可以
你比编译器多知道确定的 DOM 结构为了消掉红线随手 as any
第三方库类型写错了,你确知真实类型用断言掩盖自己没想清楚的数据结构
测试代码里构造非法输入外部数据进来时用断言当校验

一个更安全的替代:类型守卫函数 + 运行时检查(第 6 章):

typescript
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/neverany 关检查、unknown 必须先收窄、never 表示不存在
字面量类型用联合字面量表达有限的取值集合;as const 锁死对象与数组
satisfies校验形状并保留值自身推断;要保留字面量用 as const satisfies
空值处理strictNullChecks 下用 ?.、??、!= null 收窄
断言as / ! 不做运行时检查,能不用就不用

下一章预告 ​

有了基础类型,下一步是函数。下一章讲参数怎么标、返回值怎么定、回调函数怎么写类型,以及"函数重载"这个看起来高级但实际很好用的东西。

👉 第 4 章:函数与参数类型

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