Skip to content
Lv1TypeScript进度 4 / 14

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

函数是 TS 里类型信息最密集的地方:参数进、返回值出,中间还夹着回调。把函数的类型写准,整个项目的类型就立住了一半。


学习目标 ​

  • 会标注参数与返回值,并知道什么时候必须标、什么时候可以省
  • 掌握可选参数、默认参数、剩余参数的写法与顺序规则
  • 能写出正确的回调函数类型,理解 void 的特殊之处
  • 会用函数重载处理"参数不同、返回类型也不同"的场景
  • 避开"参数对象写得太宽""回调类型写死"这些常见坑

4.1 参数与返回值 ​

typescript
function formatPrice(amount: number, currency: string): string {
  return `${currency}${amount.toFixed(2)}`
}

formatPrice(19.9, '¥')     // '¥19.90'
formatPrice('19.9', '¥')   // 编译期报错

箭头函数的写法一样:

typescript
const formatPrice = (amount: number, currency: string): string =>
  `${currency}${amount.toFixed(2)}`

返回值标注有两个作用:

  1. 防止实现悄悄改变对外契约。函数体里不小心 return 了别的东西,编译器立刻报错;
  2. 加速编译。类型需要递归推断时,显式标注可以省掉一轮推导。

但也不是所有函数都要标。内部用的小工具函数(不导出、只在本文件用),让编译器推断返回类型就够了,改起来更灵活。

判断标准:导出的函数、公共 API、被多处调用的函数 → 标返回值;内部小函数 → 可省。


4.2 可选、默认、剩余参数 ​

可选参数 ​

typescript
function greet(name: string, greeting?: string): string {
  return `${greeting ?? '你好'},${name}`
}

greet('陌阡')            // '你好,陌阡'
greet('陌阡', '早上好')   // '早上好,陌阡'

? 等于在类型上加了 | undefined。可选参数必须放在必选参数后面,否则调用时没法跳过它:

typescript
function bad(a?: string, b: string) {}  // 报错

默认参数 ​

typescript
function request(url: string, timeout = 3000, retries = 2): Promise<Response> {
  // timeout: number, retries: number
}

默认值让参数自动变成可选,并且推断出类型——不用再写 : number。传 undefined 时会用默认值:

typescript
request('/api', undefined, 5)  // timeout 用 3000,retries 用 5

剩余参数 ​

typescript
function sum(...nums: number[]): number {
  return nums.reduce((a, b) => a + b, 0)
}

sum(1, 2, 3)  // 6

剩余参数的类型是数组,也可以写成元组来约束"至少几个":

typescript
function log(level: 'info' | 'warn', ...messages: [string, ...unknown[]]) {
  console.log(`[${level}]`, ...messages)
}

log('info', '用户登录')           // 正确
log('info')                        // 报错:少了一个参数

4.3 函数类型与回调 ​

函数类型用 (参数) => 返回值 表示:

typescript
type Formatter = (value: number) => string

const currencyFormatter: Formatter = (v) => `¥${v.toFixed(2)}`
const percentFormatter: Formatter = (v) => `${(v * 100).toFixed(1)}%`

注意两个细节:

  1. 参数名可以不一样。类型里的 value 只是占位,写 v、n 都行;
  2. 参数个数可以少,但不可以多。这是 JS 的天然行为(多余的参数会被忽略),TS 顺着这个行为来:
typescript
type Callback = (a: number, b: number) => void

const fn1: Callback = (a) => {}          // 可以,少收一个参数
const fn2: Callback = (a, b, c) => {}    // 报错,多收一个

回调类型怎么写 ​

typescript
// 数组方法
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:

typescript
// ❌ 回调里什么类型都没有
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 表示"不关心返回值"。它有两个反直觉但很重要的特性:

typescript
type Handler = () => void
const h1: Handler = () => 42        // 可以,返回 number 也接受
const h2: Handler = () => 'done'    // 也可以

为什么允许?因为 Handler 的语义是"调用方不会用你的返回值"。你多返回一个值,对调用方没有影响。

typescript
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 函数重载 ​

同一个函数,参数不同、返回类型不同,用重载描述:

typescript
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

要点:

  • 前面几行只有签名没有实现,叫重载签名;
  • 最后一行是实现签名,参数必须兼容所有重载签名,返回值也要兼容;
  • 调用方看到的是重载签名,实现签名对外不可见。

重载最适合"输入类型和输出类型强相关"的场景。如果只是参数数量不同,用可选参数更简单:

typescript
// 不需要重载
function createUser(name: string, age?: number): User

如果"输入是什么类型、输出就是什么类型",用泛型更优雅(第 7 章)。重载真正不可替代的场合,是返回类型无法用泛型表达的库 API,比如 DOM 的 createElement(传 'div' 返回 HTMLDivElement,传 'input' 返回 HTMLInputElement)。

实用建议:能用联合类型 + 泛型解决就别写重载。 重载写起来啰嗦,维护成本高,团队里容易被后人加一行签名就搞乱。


4.6 高阶函数与返回值类型 ​

函数返回函数,类型就是"函数的函数":

typescript
function makeLogger(prefix: string): (msg: string) => void {
  return (msg) => console.log(`[${prefix}] ${msg}`)
}

const log = makeLogger('API')
log('请求开始')

柯里化的类型也不复杂,就是逐层标注:

typescript
function multiply(a: number): (b: number) => number {
  return (b) => a * b
}

const double = multiply(2)
double(21)  // 42

如果函数本身是异步的,返回类型是 Promise<T>:

typescript
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 才值得标。

误区二:把可选参数放在必选参数前面。 → 编译直接报错。需要"前面可省、后面必须有"时,把参数改成对象:

typescript
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 最反直觉的一条规则——结构化类型。

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

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