第 5 章:对象、接口与类型别名
项目里 90% 的类型都在描述对象:接口响应、组件 props、配置项。这一章把"怎么描述一个对象"讲透。
学习目标
- 会写对象类型,区分
interface与type并知道怎么选 - 掌握可选属性、只读属性、索引签名、
Record的用法 - 理解 TS 的结构化类型规则,知道"长得像就兼容"意味着什么
- 看懂"对象字面量多余属性检查"这类报错,知道怎么处理
5.1 三种写法,先认识长相
// 1. 类型别名
type User = {
id: number
name: string
}
// 2. 接口
interface User2 {
id: number
name: string
}
// 3. 内联对象类型(只在一处用,不单独命名)
function printUser(user: { id: number; name: string }) {
console.log(`#${user.id} ${user.name}`)
}三种写法描述出来的类型是兼容的——一个 User 对象可以直接传给要 User2 的地方,因为 TS 看的是形状,不是名字。
内联写法适合"只在这个函数里用一次"的参数;需要复用、需要导出的,就抽成 interface 或 type。
小技巧:对象类型里的分隔符
,和;都可以,甚至有换行时都可以省略。团队统一一种即可,TS 官方风格偏;。
5.2 interface 还是 type
这是 TS 社区讨论最多的问题之一,结论其实很朴素。
两者的能力差异
| 能力 | interface | type |
|---|---|---|
| 描述对象形状 | ✅ | ✅ |
| 描述联合类型 | ❌ | ✅ type Status = 'ok' | 'fail' |
| 描述元组 | ❌ | ✅ type Point = [number, number] |
| 描述原始类型别名 | ❌ | ✅ type ID = string |
| 声明合并(同名多处定义自动合并) | ✅ | ❌ |
extends 继承 | ✅ | ✅(用交叉类型) |
| 实现映射类型 | ❌ | ✅(第 11 章) |
被 class implements | ✅ | ✅ |
怎么选
| 场景 | 建议 |
|---|---|
| 描述对象(DTO、props、配置) | interface |
| 需要被 class 实现 | interface |
| 联合、元组、原始类型别名 | type |
| 需要映射类型 / 条件类型加工 | type |
| 给第三方库扩充类型(模块扩充) | interface(声明合并) |
一个简单可靠的团队约定:对象用 interface,其余一律 type。 但比选哪个更重要的是——一个项目里保持统一,别一半 interface 一半 type,读代码时要来回确认。
扩展的两种写法
interface BaseUser {
id: number
}
// interface 用 extends
interface AdminUser extends BaseUser {
role: 'admin'
}
// type 用交叉类型 &
type EditorUser = BaseUser & {
articles: number
}extends 和 & 在大部分情况下等价。差别在于:extends 遇到冲突属性会直接报错(更安全),& 会把冲突属性变成 never(更隐蔽)。
5.3 可选、只读与嵌套
可选属性
interface UserProfile {
id: number
name: string
avatar?: string // string | undefined
}avatar?: string 等于 avatar: string | undefined。注意区别:
interface A { avatar?: string } // 可以没有这个键,也可以有但值是 undefined
interface B { avatar: string | undefined } // 必须有这个键,值可以是 undefined日常用 ?,只有在"键必须存在但值可能为空"(比如后端强制返回该字段)时才用后一种。
只读属性
interface Order {
readonly id: string
readonly createdAt: Date
amount: number
}
const order: Order = { id: 'A1', createdAt: new Date(), amount: 99 }
order.id = 'A2' // 报错:只读
order.amount = 100 // 可以readonly 是浅层的,只锁住这一层属性,嵌套对象照样能改:
interface Config {
readonly db: { host: string }
}
const cfg: Config = { db: { host: 'localhost' } }
cfg.db.host = 'remote' // 不报错要深层只读得逐层加,或者用工具类型(第 11 章)。React 的 props、Redux 的 state 用 readonly 很常见,能在编译期拦住"手滑改状态"。
嵌套对象
interface Address {
province: string
city: string
detail?: string
}
interface User {
id: number
name: string
address: Address // 引用另一个接口
tags: string[]
contacts: Array<{
type: 'phone' | 'email'
value: string
}> // 内联描述数组元素
}嵌套超过三层,读起来就开始费劲了。真实项目里建议每层单独命名,interface 的名字就是最好的注释。
5.4 索引签名与 Record
当对象的键是动态的(比如用 ID 做键的字典),用索引签名:
interface ScoreMap {
[studentId: string]: number
}
const scores: ScoreMap = {
s001: 90,
s002: 85
}
scores['s003'] // number(哪怕不存在,类型上也当数字)索引签名的代价:编译器无法保证那个键真的存在,scores['不存在'] 类型上是 number,运行时是 undefined。开启了 noUncheckedIndexedAccess 后,它才会变成 number | undefined——这个选项很值得开。
Record 是索引签名的语法糖:
type ScoreMap = Record<string, number>
type RoleMap = Record<'admin' | 'editor' | 'viewer', number>
// 等价于 { admin: number; editor: number; viewer: number }Record<K, V> 的两点好处:
- 键用联合类型时,会强制你把每个键都写上;
- 写法短,适合配置表、字典、缓存。
const roleLabels: Record<'admin' | 'editor' | 'viewer', string> = {
admin: '管理员',
editor: '编辑',
viewer: '访客'
}
// 少写一个键就报错5.5 结构化类型:长得像就行
这是 TS 和 Java 最大的观念差异。
interface Point {
x: number
y: number
}
interface Coordinate {
x: number
y: number
}
const p: Point = { x: 1, y: 2 }
const c: Coordinate = p // 完全合法Java 里两个不同名的类不能互传,TS 里只要结构兼容就可以。这叫结构化类型(structural typing),也叫"鸭子类型"的类型化版本:如果它走起来像鸭子、叫起来像鸭子,那它就是鸭子。
好处:不用为了兼容去写一堆适配代码,第三方库的类型和你的类型天然能对接。 代价:拼错字段名、传错对象时,报错信息可能出现在很远的地方。
多余属性检查
结构化类型有一个例外:直接写对象字面量时,多出来的属性会报错。
interface User {
id: number
name: string
}
const u: User = { id: 1, name: 'a', age: 20 }
// 报错:对象字面量只能指定已知属性,'age' 不在类型 'User' 中为什么?这是 TS 故意的"新鲜对象检查"(excess property check),防止你把拼错的字段名当成合法属性传进去。
绕过它有三种方式,各有代价:
// 1. 先赋给变量,再传(跳过字面量检查,但失去了一次保护)
const raw = { id: 1, name: 'a', age: 20 }
const u: User = raw // 不报错
// 2. 加索引签名,允许额外属性(放弃了检查)
interface UserWithExtra {
id: number
name: string
[key: string]: unknown
}
// 3. 用 satisfies 校验必须的部分(TS 4.9+)
const u2 = { id: 1, name: 'a', age: 20 } satisfies User & { age: number }日常最推荐第 1 种或第 3 种:真的需要多余字段时,说明类型定义该更新了,而不是绕过检查。
函数参数是"逆变"的
结构化类型在函数上表现得更严格:
interface Animal { name: string }
interface Dog extends Animal { bark(): void }
let handleAnimal: (a: Animal) => void
let handleDog: (d: Dog) => void
handleAnimal = handleDog // 报错:Dog 要求更具体
handleDog = handleAnimal // 可以:能处理所有 Animal,当然能处理 Dog一句话记:参数类型越宽的函数,能赋值给参数类型越窄的位置。 这条规则(strictFunctionTypes)拦住了一类真实 bug:把一个只认 Dog 的函数当成"能处理所有动物"来用。
5.6 对象里的方法怎么写
interface Calculator {
// 属性写法(函数类型)
add: (a: number, b: number) => number
// 方法写法(简写)
sub(a: number, b: number): number
}两种写法几乎等价,唯一区别是方法写法在 strictFunctionTypes 下检查稍宽松(方法参数是双变的)。团队统一一种就好,推荐方法简写,少一层箭头看起来更清爽。
5.7 常见误区
误区一:interface 比 type 高级,所以全用 interface。 → 描述联合类型、元组、原始类型别名时 interface 根本做不到。按 5.2 的表来选。
误区二:readonly 能锁住整个对象。 → 只锁一层。嵌套对象照样可变,需要深层只读得逐层加或写工具类型。
误区三:以为 interface 和 type 可以随便互换,混着用。 → 能互换的只有对象那部分。混着用最大的问题是读代码的人要反复确认"这个类型能不能被继承、能不能合并"。
误区四:遇到多余属性报错就加 as any。 → 先确认是不是字段名拼错了,或者类型定义漏了字段。真的需要多余字段,就更新类型。
误区五:索引签名当成"什么键都有值"的保证。 → 类型上 map[k] 是 V,运行时可能是 undefined。开 noUncheckedIndexedAccess 或使用前判空。
本章小结
| 要点 | 说明 |
|---|---|
| 三种写法 | type、interface、内联对象类型,形状兼容 |
interface vs type | 对象用 interface;联合/元组/映射类型用 type |
| 扩展 | extends(冲突报错)与交叉 &(冲突变 never) |
| 可选属性 | ? 等价于 | undefined,表示键可以不存在 |
readonly | 浅层只读,常配合 props / state |
| 索引签名 | [k: string]: V;Record<K, V> 是语法糖,键用联合类型可强制写全 |
| 结构化类型 | 结构兼容即可赋值,不看类型名字 |
| 多余属性检查 | 只针对新鲜对象字面量,是保护不是 bug |
| 函数参数 | 参数宽的函数可赋给参数窄的位置(逆变) |
下一章预告
前面的类型都是"一个形状"。真实数据经常是"几种可能之一"——成功或失败、有值或没值。下一章讲联合类型和类型收窄,这是 TS 里最能减少运行时 bug 的一块。