TypeScript 函数：参数类型、返回类型与 void

TypeScript 函数就是给参数加上类型、并可选地给返回值加上类型的 JavaScript 函数。每个参数都有一个标注，返回类型写在参数列表之后，编译器会按这两者检查每一次调用。

function area(width: number, height: number): number {
  return width * height;
}

console.log(area(3, 4)); // 12

// @ts-expect-error: Argument of type 'string' is not assignable to parameter of type 'number'.
area("3", 4);

// @ts-expect-error: Expected 2 arguments, but got 1.
area(3);

两个错误的调用都是编译期错误（TS2345 和 TS2554）。// @ts-expect-error 注释告诉编译器下一行预期会出错，所以文件的其余部分仍然能运行。删掉其中一条再运行一次，就能看到真实的报错信息。

参数类型

每个参数都写成 name: Type。在 strict 下（TypeScript 7 默认开启），如果一个参数既没有标注，又没有可供推断的上下文，就会报错：Parameter 'x' implicitly has an 'any' type.（TS7006）。所以实际上，独立函数的每个参数都要加标注。

任何类型都可以作为参数类型：基本类型、数组、对象类型、联合类型，以及其他函数。

type User = { name: string; tags: string[] };

function describe(user: User, maxTags: number): string {
  const shown = user.tags.slice(0, maxTags).join(", ");
  return `${user.name} (${shown})`;
}

function formatId(id: string | number): string {
  return typeof id === "number" ? id.toFixed(0).padStart(5, "0") : id.toUpperCase();
}

console.log(describe({ name: "Ada", tags: ["math", "code", "tea"] }, 2)); // Ada (math, code)
console.log(formatId(42));      // 00042
console.log(formatId("ab-7"));  // AB-7

TypeScript 也会检查参数的个数。传入的实参比函数声明的多或少都会报错，这和普通 JavaScript 不同，后者会用 undefined 填补缺少的参数并忽略多余的参数。要让参数变成可选的或给它一个默认值，见可选参数。

返回类型：标注还是推断

返回类型跟在右括号之后：function f(): Type。它是可选的。没有标注时，TypeScript 会根据函数体中的每一个 return 推断类型。

// Inferred: (n: number) => "even" | "odd"
function parity(n: number) {
  return n % 2 === 0 ? "even" : "odd";
}

// Annotated: the contract is written down
function average(values: number[]): number {
  if (values.length === 0) return 0;
  const sum = values.reduce((acc, v) => acc + v, 0);
  return sum / values.length;
}

const p = parity(7);
console.log(p, average([2, 4, 9])); // odd 5

当函数被导出、有多条返回路径或者是递归函数时，标注就很有价值。这样错误会出现在函数内部那个错误的 return 处，而不是出现在调用方。一个典型的例子是某个分支忘了返回：

// This does not compile: one path falls off the end of the function.
function grade(score: number): string {
  if (score >= 90) return "A";
  if (score >= 80) return "B";
}

console.log(grade(85));

编译器报告 index.ts(2,32): error TS2366: Function lacks ending return statement and return type does not include 'undefined'.。在最后加上 return "C"; 就能运行。如果没有 : string 标注，这个函数会以推断出的类型 "A" | "B" | undefined 通过编译，问题就转移到了使用结果的地方。

void：不返回任何值的函数

只负责做事（打印日志、写入数据、修改状态）的函数，返回类型是 void。没有带值的 return 时，TypeScript 推断出的就是它，你也可以显式写出来。

function logLine(label: string, value: number): void {
  console.log(`${label.padEnd(8)}${value}`);
}

logLine("apples", 3);
logLine("pears", 12);

// A callback typed as returning void may return a value; it is ignored.
const lengths: number[] = [];
const push: (s: string) => void = (s) => lengths.push(s.length);
["a", "bcd"].forEach(push);
console.log(lengths); // [ 1, 3 ]

关于 void 的这些规则常常让人意外：

第二行是有意为之的。正因如此，即使 push 返回一个数字，arr.forEach(x => list.push(x)) 也能通过编译。函数类型中的 void 意思是“不管它返回什么，都没人会读”。对于永远不会返回的函数（总是抛出错误或无限循环），返回类型是 never。

箭头函数与函数表达式

箭头函数和函数表达式使用同样的标注。返回类型写在参数列表之后、=> 之前。

const double = (n: number): number => n * 2;

const toUpper = function (s: string): string {
  return s.toUpperCase();
};

// Returning an object literal from an arrow needs parentheses.
const point = (x: number, y: number) => ({ x, y });

console.log(double(21), toUpper("ok")); // 42 OK
console.log(point(1, 2));               // { x: 1, y: 2 }

如果没有括号，(x, y) => { x, y } 就是一个没有 return 的代码块，函数返回 undefined。箭头函数的运行时规则（没有自己的 this，没有 arguments）和 JavaScript 中一样；见 JavaScript 中的箭头函数。

当函数作为实参内联书写时，通常完全不需要标注它的参数。TypeScript 能从接收它的函数知道回调会收到什么（上下文类型推断）：在 [1, 2].map(n => n * 2) 中，n 已经是 number。把函数的类型写成一个值的类型，即 (n: number) => string，见函数类型。

返回多个值

函数只能返回一个值，所以返回一个对象或元组，再进行解构。

function minMax(values: number[]): { min: number; max: number } {
  return { min: Math.min(...values), max: Math.max(...values) };
}

function splitName(full: string): [first: string, last: string] {
  const i = full.indexOf(" ");
  return [full.slice(0, i), full.slice(i + 1)];
}

const { min, max } = minMax([7, 2, 9]);
const [first, last] = splitName("Grace Hopper");
console.log(min, max, first, last); // 2 9 Grace Hopper

元组返回类型需要标注。没有标注时，[a, b] 会被推断为 string[]：解构仍然可以工作，但类型不再说明恰好有两个元素。

async 函数

async 函数总是返回一个 Promise。把返回类型标注为 Promise<T>，其中 T 是函数内部返回的值的类型。

async function loadScore(id: number): Promise<number> {
  await new Promise((resolve) => setTimeout(resolve, 10));
  return id * 10;
}

async function main(): Promise<void> {
  const score = await loadScore(4); // score: number
  console.log("score", score);
}

main();

写成 async function f(): number 会报错：The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<number>'?（TS1064）。

this 参数

JavaScript 在调用时才决定 this。TypeScript 允许你用一个名为 this 的假的第一个参数，来声明 this 必须是什么。它会从编译后的 JavaScript 中删除，调用方也不需要传入它。

interface Counter {
  count: number;
}

function increment(this: Counter, by: number): void {
  this.count += by;
}

const c = { count: 0, increment };
c.increment(2); // fine: this is c

increment(2);
// error TS2684: The 'this' context of type 'void' is not assignable to method's 'this' of type 'Counter'.

如果没有 this 参数，独立函数中的 this 就是隐式的 any，严格模式会报告 'this' implicitly has type 'any' because it does not have a type annotation.（TS2683）。在类方法中，this 的类型已经是类的实例，所以这个参数主要用于挂在对象上的独立函数，以及库会用特定 this 调用的回调。