函数

函数类型在 TypeScript 类型系统中扮演着非常重要的角色，它们是可组合系统的核心构建块。

参数注解

你可以注解函数参数，就像你可以注解其他变量一样:

  1. // variable annotation
  2. let sampleVariable: { bar: number };
  4. // function parameter annotation
  5. function foo(sampleParameter: { bar: number }) {}

这里我们使用了内联类型注解，除此之外，你还可以使用接口等其他方式。

返回类型注解

你可以在函数参数列表之后使用与变量相同的样式来注解返回类型，如例子中 ：Foo：

  1. interface Foo {
  2.   foo: string;
  3. }
  5. // Return type annotated as `: Foo`
  6. function foo(sample: Foo): Foo {
  7.   return sample;
  8. }

我们在这里使用了一个 interface，但你可以自由地使用其他注解方式，例如内联注解。

通常，你不需要注解函数的返回类型，因为它可以由编译器推断：

  1. interface Foo {
  2.   foo: string;
  3. }
  5. function foo(sample: Foo) {
  6.   return sample; // inferred return type 'Foo'
  7. }

但是，添加这些注解以帮助解决错误提示通常是一个好主意，例如：

  1. function foo() {
  2.   return { fou: 'John Doe' }; // You might not find this misspelling of `foo` till it's too late
  3. }
  5. sendAsJSON(foo());

如果你不打算从函数返回任何内容，则可以将其标注为：void 。你通常可以删除 void， TypeScript 能推导出来：

可选参数

你可以将参数标记为可选:

  1. function foo(bar: number, bas?: string): void {
  2.   // ..
  3. }
  5. foo(123);
  6. foo(123, 'hello');

或者，当调用者没有提供该参数时，你可以提供一个默认值（在参数声明后使用 = someValue ）：

  1. function foo(bar: number, bas: string = 'hello') {
  2.   console.log(bar, bas);
  3. }
  5. foo(123); // 123, hello
  6. foo(123, 'world'); // 123, world

重载

TypeScript 允许你声明函数重载。这对于文档 + 类型安全来说很实用。请思考以下代码：

  1. function padding(a: number, b?: number, c?: number, d?: any) {
  2.   if (b === undefined && c === undefined && d === undefined) {
  3.     b = c = d = a;
  4.   } else if (c === undefined && d === undefined) {
  5.     c = a;
  6.     d = b;
  7.   }
  8.   return {
  9.     top: a,
  10.     right: b,
  11.     bottom: c,
  12.     left: d
  13.   };
  14. }

如果仔细查看代码，就会发现 a，b，c，d 的值会根据传入的参数数量而变化。此函数也只需要 1 个，2 个或 4 个参数。可以使用函数重载来强制和记录这些约束。你只需多次声明函数头。最后一个函数头是在函数体内实际处于活动状态但不可用于外部。

如下所示:

  1. // 重载
  2. function padding(all: number);
  3. function padding(topAndBottom: number, leftAndRight: number);
  4. function padding(top: number, right: number, bottom: number, left: number);
  5. // Actual implementation that is a true representation of all the cases the function body needs to handle
  6. function padding(a: number, b?: number, c?: number, d?: number) {
  7.   if (b === undefined && c === undefined && d === undefined) {
  8.     b = c = d = a;
  9.   } else if (c === undefined && d === undefined) {
  10.     c = a;
  11.     d = b;
  12.   }
  13.   return {
  14.     top: a,
  15.     right: b,
  16.     bottom: c,
  17.     left: d
  18.   };
  19. }

这里前三个函数头可有效调用 padding:

  1. padding(1); // Okay: all
  2. padding(1, 1); // Okay: topAndBottom, leftAndRight
  3. padding(1, 1, 1, 1); // Okay: top, right, bottom, left
  5. padding(1, 1, 1); // Error: Not a part of the available overloads

当然，最终声明（从函数内部看到的真正声明）与所有重载兼容是很重要的。这是因为这是函数体需要考虑的函数调用的真实性质。

TIP

TypeScript 中的函数重载没有任何运行时开销。它只允许你记录希望调用函数的方式，并且编译器会检查其余代码。

原文: https://jkchao.github.io/typescript-book-chinese/typings/functions.html