第 4 章:函数与参数类型
函数是 TS 里类型信息最密集的地方:参数进、返回值出,中间还夹着回调。把函数的类型写准,整个项目的类型就立住了一半。
学习目标
- 会标注参数与返回值,并知道什么时候必须标、什么时候可以省
- 掌握可选参数、默认参数、剩余参数的写法与顺序规则
- 能写出正确的回调函数类型,理解
void的特殊之处 - 会用函数重载处理"参数不同、返回类型也不同"的场景
- 避开"参数对象写得太宽""回调类型写死"这些常见坑
4.1 参数与返回值
function formatPrice(amount: number, currency: string): string {
return `${currency}${amount.toFixed(2)}`
}
formatPrice(19.9, '¥') // '¥19.90'
formatPrice('19.9', '¥') // 编译期报错箭头函数的写法一样:
const formatPrice = (amount: number, currency: string): string =>
`${currency}${amount.toFixed(2)}`返回值标注有两个作用:
- 防止实现悄悄改变对外契约。函数体里不小心
return了别的东西,编译器立刻报错; - 加速编译。类型需要递归推断时,显式标注可以省掉一轮推导。
但也不是所有函数都要标。内部用的小工具函数(不导出、只在本文件用),让编译器推断返回类型就够了,改起来更灵活。
判断标准:导出的函数、公共 API、被多处调用的函数 → 标返回值;内部小函数 → 可省。
4.2 可选、默认、剩余参数
可选参数
function greet(name: string, greeting?: string): string {
return `${greeting ?? '你好'},${name}`
}
greet('陌阡') // '你好,陌阡'
greet('陌阡', '早上好') // '早上好,陌阡'? 等于在类型上加了 | undefined。可选参数必须放在必选参数后面,否则调用时没法跳过它:
function bad(a?: string, b: string) {} // 报错默认参数
function request(url: string, timeout = 3000, retries = 2): Promise<Response> {
// timeout: number, retries: number
}默认值让参数自动变成可选,并且推断出类型——不用再写 : number。传 undefined 时会用默认值:
request('/api', undefined, 5) // timeout 用 3000,retries 用 5剩余参数
function sum(...nums: number[]): number {
return nums.reduce((a, b) => a + b, 0)
}
sum(1, 2, 3) // 6剩余参数的类型是数组,也可以写成元组来约束"至少几个":
function log(level: 'info' | 'warn', ...messages: [string, ...unknown[]]) {
console.log(`[${level}]`, ...messages)
}
log('info', '用户登录') // 正确
log('info') // 报错:少了一个参数4.3 函数类型与回调
函数类型用 (参数) => 返回值 表示:
type Formatter = (value: number) => string
const currencyFormatter: Formatter = (v) => `¥${v.toFixed(2)}`
const percentFormatter: Formatter = (v) => `${(v * 100).toFixed(1)}%`注意两个细节:
- 参数名可以不一样。类型里的
value只是占位,写v、n都行; - 参数个数可以少,但不可以多。这是 JS 的天然行为(多余的参数会被忽略),TS 顺着这个行为来:
type Callback = (a: number, b: number) => void
const fn1: Callback = (a) => {} // 可以,少收一个参数
const fn2: Callback = (a, b, c) => {} // 报错,多收一个回调类型怎么写
// 数组方法
const nums = [1, 2, 3]
nums.map((n): string => `#${n}`)
// 事件回调
function onClick(handler: (event: MouseEvent) => void) {
document.addEventListener('click', handler)
}
// 异步回调
type AsyncHandler<T> = (err: Error | null, data?: T) => Promise<void> | void一个常见的写法错误是把回调参数写成 any:
// ❌ 回调里什么类型都没有
function forEach(items: any[], cb: (item: any) => void) {}
// ✅ 用泛型把元素类型传下去
function forEach2<T>(items: T[], cb: (item: T) => void) {
items.forEach(cb)
}第 7 章会详细讲泛型,这里先记住:只要函数要处理"某一类元素",就该考虑泛型,而不是 any。
4.4 void 的真实含义
void 表示"不关心返回值"。它有两个反直觉但很重要的特性:
type Handler = () => void
const h1: Handler = () => 42 // 可以,返回 number 也接受
const h2: Handler = () => 'done' // 也可以为什么允许?因为 Handler 的语义是"调用方不会用你的返回值"。你多返回一个值,对调用方没有影响。
function run(cb: () => void) {
cb()
}
run(() => {
return 100 // 不报错,但 run 里拿不到这个值
})对比一下:如果写成 () => undefined,就必须真的返回 undefined,反而不如 void 通用。所以回调类型的返回值一律写 void,除非你真的要用它的返回值。
void 和 undefined 的区别:
| 写法 | 含义 |
|---|---|
function f(): void | 不返回任何有用的值(可以 return;,不能 return 1) |
function f(): undefined | 必须返回 undefined |
type Cb = () => void | 调用方不关心返回值,你返回什么都可以 |
4.5 函数重载
同一个函数,参数不同、返回类型不同,用重载描述:
function parseInput(input: string): string[]
function parseInput(input: number): number
function parseInput(input: string | number): string[] | number {
if (typeof input === 'string') return input.split(',')
return input * 2
}
parseInput('a,b') // string[]
parseInput(3) // number要点:
- 前面几行只有签名没有实现,叫重载签名;
- 最后一行是实现签名,参数必须兼容所有重载签名,返回值也要兼容;
- 调用方看到的是重载签名,实现签名对外不可见。
重载最适合"输入类型和输出类型强相关"的场景。如果只是参数数量不同,用可选参数更简单:
// 不需要重载
function createUser(name: string, age?: number): User如果"输入是什么类型、输出就是什么类型",用泛型更优雅(第 7 章)。重载真正不可替代的场合,是返回类型无法用泛型表达的库 API,比如 DOM 的 createElement(传 'div' 返回 HTMLDivElement,传 'input' 返回 HTMLInputElement)。
实用建议:能用联合类型 + 泛型解决就别写重载。 重载写起来啰嗦,维护成本高,团队里容易被后人加一行签名就搞乱。
4.6 高阶函数与返回值类型
函数返回函数,类型就是"函数的函数":
function makeLogger(prefix: string): (msg: string) => void {
return (msg) => console.log(`[${prefix}] ${msg}`)
}
const log = makeLogger('API')
log('请求开始')柯里化的类型也不复杂,就是逐层标注:
function multiply(a: number): (b: number) => number {
return (b) => a * b
}
const double = multiply(2)
double(21) // 42如果函数本身是异步的,返回类型是 Promise<T>:
async function fetchJson<T>(url: string): Promise<T> {
const res = await fetch(url)
return res.json() as Promise<T>
}注意这里的 as Promise<T> 是第 3 章说的断言——res.json() 返回 Promise<any>,不做运行时校验。真实项目要在这一层加校验(第 14 章),否则类型只是自我安慰。
4.7 常见误区
误区一:所有函数都标一遍返回类型。 → 内部小函数标了反而碍事,改动时多一处要同步。导出的 API 才值得标。
误区二:把可选参数放在必选参数前面。 → 编译直接报错。需要"前面可省、后面必须有"时,把参数改成对象:
function create(opts: { name: string; age?: number }) {}
create({ name: 'a' })误区三:回调返回值也标成具体类型。 → type Cb = () => number 会逼所有传入的回调都返回数字。除非你真要用返回值,否则一律 void。
误区四:参数对象写成 any 或拆成一大堆位置参数。 → 参数超过 3 个就该换成对象;对象里的字段要写清楚,可选字段用 ?。
误区五:以为重载能写在箭头函数上。 → 重载必须用 function 声明,箭头函数不支持。
本章小结
| 要点 | 说明 |
|---|---|
| 参数标注 | 参数必须标(有默认值除外);返回类型对外 API 要标 |
| 可选参数 | ? 表示可能为 undefined,必须放在必选参数之后 |
| 默认参数 | 自动可选并推断类型;传 undefined 会使用默认值 |
| 剩余参数 | ...nums: number[];元组形式可约束最少个数 |
| 回调类型 | (a: T) => void;参数名无关,参数个数可少不可多 |
void | 表示不关心返回值,实现可以返回任意值 |
| 重载 | 只用于"输入类型决定输出类型"且泛型表达不了的场景 |
| 参数过多 | 超过 3 个改用对象参数 |
下一章预告
函数写顺了,接下来是数据。下一章讲对象类型、
interface和type到底怎么选、可选与只读属性、索引签名,以及 TS 最反直觉的一条规则——结构化类型。