Skip to content
Lv1TypeScript进度 5 / 14

第 5 章:对象、接口与类型别名 ​

项目里 90% 的类型都在描述对象:接口响应、组件 props、配置项。这一章把"怎么描述一个对象"讲透。


学习目标 ​

  • 会写对象类型,区分 interface 与 type 并知道怎么选
  • 掌握可选属性、只读属性、索引签名、Record 的用法
  • 理解 TS 的结构化类型规则,知道"长得像就兼容"意味着什么
  • 看懂"对象字面量多余属性检查"这类报错,知道怎么处理

5.1 三种写法,先认识长相 ​

typescript
// 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 社区讨论最多的问题之一,结论其实很朴素。

两者的能力差异 ​

能力interfacetype
描述对象形状✅✅
描述联合类型❌✅ 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,读代码时要来回确认。

扩展的两种写法 ​

typescript
interface BaseUser {
  id: number
}

// interface 用 extends
interface AdminUser extends BaseUser {
  role: 'admin'
}

// type 用交叉类型 &
type EditorUser = BaseUser & {
  articles: number
}

extends 和 & 在大部分情况下等价。差别在于:extends 遇到冲突属性会直接报错(更安全),& 会把冲突属性变成 never(更隐蔽)。


5.3 可选、只读与嵌套 ​

可选属性 ​

typescript
interface UserProfile {
  id: number
  name: string
  avatar?: string   // string | undefined
}

avatar?: string 等于 avatar: string | undefined。注意区别:

typescript
interface A { avatar?: string }      // 可以没有这个键,也可以有但值是 undefined
interface B { avatar: string | undefined }  // 必须有这个键,值可以是 undefined

日常用 ?,只有在"键必须存在但值可能为空"(比如后端强制返回该字段)时才用后一种。

只读属性 ​

typescript
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 是浅层的,只锁住这一层属性,嵌套对象照样能改:

typescript
interface Config {
  readonly db: { host: string }
}

const cfg: Config = { db: { host: 'localhost' } }
cfg.db.host = 'remote'  // 不报错

要深层只读得逐层加,或者用工具类型(第 11 章)。React 的 props、Redux 的 state 用 readonly 很常见,能在编译期拦住"手滑改状态"。

嵌套对象 ​

typescript
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 做键的字典),用索引签名:

typescript
interface ScoreMap {
  [studentId: string]: number
}

const scores: ScoreMap = {
  s001: 90,
  s002: 85
}

scores['s003']  // number(哪怕不存在,类型上也当数字)

索引签名的代价:编译器无法保证那个键真的存在,scores['不存在'] 类型上是 number,运行时是 undefined。开启了 noUncheckedIndexedAccess 后,它才会变成 number | undefined——这个选项很值得开。

Record 是索引签名的语法糖:

typescript
type ScoreMap = Record<string, number>
type RoleMap = Record<'admin' | 'editor' | 'viewer', number>
// 等价于 { admin: number; editor: number; viewer: number }

Record<K, V> 的两点好处:

  1. 键用联合类型时,会强制你把每个键都写上;
  2. 写法短,适合配置表、字典、缓存。
typescript
const roleLabels: Record<'admin' | 'editor' | 'viewer', string> = {
  admin: '管理员',
  editor: '编辑',
  viewer: '访客'
}
// 少写一个键就报错

5.5 结构化类型:长得像就行 ​

这是 TS 和 Java 最大的观念差异。

typescript
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),也叫"鸭子类型"的类型化版本:如果它走起来像鸭子、叫起来像鸭子,那它就是鸭子。

好处:不用为了兼容去写一堆适配代码,第三方库的类型和你的类型天然能对接。 代价:拼错字段名、传错对象时,报错信息可能出现在很远的地方。

多余属性检查 ​

结构化类型有一个例外:直接写对象字面量时,多出来的属性会报错。

typescript
interface User {
  id: number
  name: string
}

const u: User = { id: 1, name: 'a', age: 20 }
// 报错:对象字面量只能指定已知属性,'age' 不在类型 'User' 中

为什么?这是 TS 故意的"新鲜对象检查"(excess property check),防止你把拼错的字段名当成合法属性传进去。

绕过它有三种方式,各有代价:

typescript
// 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 种:真的需要多余字段时,说明类型定义该更新了,而不是绕过检查。

函数参数是"逆变"的 ​

结构化类型在函数上表现得更严格:

typescript
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 对象里的方法怎么写 ​

typescript
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 的一块。

👉 第 6 章:联合、交叉与类型收窄

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