函数
简介
函数的类型声明，需要在声明函数时，给出参数的类型和返回值的类型。
function hello(txt: string): void {console.log("hello " + txt);
}
如果变量被赋值为一个函数，变量的类型有两种写法。
// 写法一
const hello = function (txt: string) {console.log("hello " + txt);
};// 写法二
const hello: (txt: string) => void = function (txt) {console.log("hello " + txt);
};
函数类型里面的参数名与实际参数名，可以不一致。
let f: (x: number) => number;f = function (y: number) {return y;
};
用 type 命令为函数类型定义一个别名，便于指定给其他变量。
type MyFunc = (txt: string) => void;const hello: MyFunc = function (txt) {console.log("hello " + txt);
};
函数的实际参数个数，可以少于类型指定的参数个数，但是不能多于，即 TypeScript 允许省略参数。
let myFunc: (a: number, b: number) => number;myFunc = (a: number) => a; // 正确myFunc = (a: number, b: number, c: number) => a + b + c; // 报错
如果一个变量要套用另一个函数类型，可以使用 typeof 运算符。
function add(x: number, y: number) {return x + y;
}const myAdd: typeof add = function (x, y) {return x + y;
};
函数类型还可以采用对象的写法。
{(参数列表): 返回值
}
let add: {(x: number, y: number): number;
};add = function (x, y) {return x + y;
};
对象写法非常适用在函数有属性的场合。
function f(x: number) {console.log(x);
}
f.version = "1.0";let foo: {(x: number): void;version: string;
} = f;
函数类型也可以使用 Interface 来声明。
interface myfn {(a: number, b: number): number;
}var add: myfn = (a, b) => a + b;
Function 类型
TypeScript 提供 Function 类型表示函数，任何函数都属于这个类型。
function doSomething(f: Function) {return f(1, 2, 3);
}
Function 类型的值都可以直接执行。
Function 类型的函数可以接受任意数量的参数，每个参数的类型都是 any，返回值的类型也是 any，代表没有任何约束，所以不建议使用这个类型，给出函数详细的类型声明会更好。
箭头函数
const repeat = (str: string, times: number): string => str.repeat(times);
function greet(fn: (a: string) => void): void {fn("world");
}
fn 的类型是(a: string) => void
type Person = { name: string };const people = ["alice", "bob", "jan"].map((name): Person => ({ name }));
people 的类型是 Person[]
可选参数
如果函数的某个参数可以省略，则在参数名后面加问号表示。
参数名带有问号，表示该参数的类型实际上是原始类型|undefined，它有可能为 undefined。
function f(x?: number) {return x;
}f(undefined); // 正确
f(); // 正确
f(10); // 正确
函数的可选参数只能在参数列表的尾部，跟在必选参数的后面。
函数体内部用到可选参数时，需要判断该参数是否为 undefined。
let myFunc: (a: number, b?: number) => number;myFunc = function (x, y) {if (y === undefined) {return x;}return x + y;
};
参数默认值
TypeScript 函数的参数默认值写法，与 JavaScript 一致。
设置了默认值的参数，就是可选的。如果不传入该参数，它就会等于默认值。
可选参数与默认值不能同时使用。
设有默认值的参数，如果传入 undefined，也会触发默认值。
function f(x = 456) {return x;
}f(undefined); // 456
具有默认值的参数如果不位于参数列表的末尾，调用时不能省略，如果要触发默认值，必须显式传入 undefined。
function add(x: number = 0, y: number) {return x + y;
}add(1); // 报错
add(undefined, 1); // 正确
参数解构
函数参数如果存在变量解构，类型写法如下：
function f([x, y]: [number, number]) {// ...
}function sum({ a, b, c }: { a: number; b: number; c: number }) {console.log(a + b + c);
}
参数解构可以结合类型别名（type）一起使用，代码会看起来简洁一些。
type ABC = { a: number; b: number; c: number };function sum({ a, b, c }: ABC) {console.log(a + b + c);
}
rest 参数
rest 参数表示函数剩余的所有参数，它可以是数组（剩余参数类型相同），也可能是元组（剩余参数类型不同）。
// rest 参数为数组
function joinNumbers(...nums: number[]) {// ...
}// rest 参数为元组
function f(...args: [boolean, number]) {// ...
}
如果元组里面的参数是可选的，则要使用可选参数。
function f(...args: [boolean, string?]) {}
rest 参数甚至可以嵌套。
function f(...args: [boolean, ...number[]]) {// ...
}
f(true, 12, 45, 67);
rest 参数可以与变量解构结合使用。
function repeat(...[str, times]: [string, number]): string {return str.repeat(times);
}// 等同于
function repeat(str: string, times: number): string {return str.repeat(times);
}
readonly 只读参数
如果函数内部不能修改某个参数，可以在函数定义时，在参数类型前面加上 readonly 关键字，表示这是只读参数。
function arraySum(arr: readonly number[]) {// ...arr[0] = 0; // 报错
}
::: tip
readonly 关键字目前只允许用在数组和元组类型的参数前面，如果用在其他类型的参数前面，就会报错。
:::
void 类型
void 类型表示函数没有返回值。如果返回其他值，就会报错。
void 类型允许返回 undefined 或 null。
::: tip
如果变量、对象方法、函数参数是一个返回值为 void 类型的函数，那么并不代表不能赋值为有返回值的函数。恰恰相反，该变量、对象方法和函数参数可以接受返回任意值的函数，这时并不会报错。但是如果后面使用了这个函数的返回值，就违反了约定，则会报错。
:::
type voidFunc = () => void;const f: voidFunc = () => {return 123;
};f() * 2; // 报错
函数的运行结果如果是抛出错误，也允许将返回值写成 void。
function throwErr(): void {throw new Error("something wrong");
}
never 类型
never 类型表示肯定不会出现的值。它用在函数的返回值，就表示某个函数肯定不会返回值，即函数不会正常执行结束。它主要有以下两种情况。
（1）抛出错误的函数。
function fail(msg: string): never {throw new Error(msg);
}
:::tip
只有抛出错误，才是 never 类型。如果显式用 return 语句返回一个 Error 对象，返回值就不是 never 类型。
:::
由于抛出错误的情况属于 never 类型或 void 类型，所以无法从返回值类型中获知，抛出的是哪一种错误。
（2）无限执行的函数。
const sing = function (): never {while (true) {console.log("sing");}
};
:::tip
never 类型不同于 void 类型。前者表示函数没有执行结束，不可能有返回值；后者表示函数正常执行结束，但是不返回值，或者说返回 undefined。
:::
如果一个函数抛出了异常或者陷入了死循环，那么该函数无法正常返回一个值，因此该函数的返回值类型就是 never。如果程序中调用了一个返回值类型为 never 的函数，那么就意味着程序会在该函数的调用位置终止，永远不会继续执行后续的代码。
function neverReturns(): never {throw new Error();
}function f(x: string | undefined) {if (x === undefined) {neverReturns();}x; // 推断为 string
}
一个函数如果某些条件下有正常返回值，另一些条件下抛出错误，这时它的返回值类型可以省略 never。
function sometimesThrow(): number {if (Math.random() > 0.5) {return 100;}throw new Error("Something went wrong");
}const result = sometimesThrow();
因为 never 是 TypeScript 的唯一一个底层类型，所有其他类型都包括了 never。
局部类型
函数内部允许声明其他类型，该类型只在函数内部有效，称为局部类型。
function hello(txt: string) {type message = string;let newTxt: message = "hello " + txt;return newTxt;
}const newTxt: message = hello("world"); // 报错
高阶函数
一个函数的返回值还是一个函数，那么前一个函数就称为高阶函数（higher-order function）。
(someValue: number) => (multiplier: number) => someValue * multiplier;
函数重载
有些函数可以接受不同类型或不同个数的参数，并且根据参数的不同，会有不同的函数行为。这种根据参数类型不同，执行不同逻辑的行为，称为函数重载（function overload）。
TypeScript 对于“函数重载”的类型声明方法是，逐一定义每一种情况的类型。
// 列举重载的各种情况
function reverse(str: string): string;
function reverse(arr: any[]): any[];
// 函数本身的类型声明
function reverse(stringOrArray: string | any[]): string | any[] {if (typeof stringOrArray === "string") {return stringOrArray.split("").reverse().join("");} else {return stringOrArray.slice().reverse();}
}
函数本身的类型声明，它必须与前面已有的重载声明兼容。
:::tip
重载的各个类型描述与函数的具体实现之间，不能有其他代码，否则报错。
:::
函数重载的每个类型声明之间，以及类型声明与函数实现的类型之间，不能有冲突。
重载声明的排序很重要，因为 TypeScript 是按照顺序进行检查的，一旦发现符合某个类型声明，就不再往下检查了，所以类型最宽的声明应该放在最后面，防止覆盖其他类型声明。
对象的方法也可以使用重载。
class StringBuilder {#data = "";add(num: number): this;add(bool: boolean): this;add(str: string): this;add(value: any): this {this.#data += String(value);return this;}toString() {return this.#data;}
}
函数重载也可以用来精确描述函数参数与返回值之间的对应关系。
function createElement(tag: "a"): HTMLAnchorElement;
function createElement(tag: "canvas"): HTMLCanvasElement;
function createElement(tag: "table"): HTMLTableElement;
function createElement(tag: string): HTMLElement {// ...
}
也可以用对象表示为
type CreateElement = {(tag: "a"): HTMLAnchorElement;(tag: "canvas"): HTMLCanvasElement;(tag: "table"): HTMLTableElement;(tag: string): HTMLElement;
};
一般来说，如果可以的话，应该优先使用联合类型替代函数重载，除非多个参数之间、或者某个参数与返回值之间，存在对应关系。
// 写法一
function len(s: string): number;
function len(arr: any[]): number;
function len(x: any): number {return x.length;
}// 写法二
function len(x: any[] | string): number {return x.length;
}
构造函数
构造函数的最大特点，就是必须使用 new 命令调用。
构造函数的类型写法，就是在参数列表前面加上 new 命令。
class Animal {numLegs: number = 4;
}type AnimalConstructor = new () => Animal;function create(c: AnimalConstructor): Animal {return new c();
}const a = create(Animal);
构造函数还有另一种类型写法，就是采用对象形式。
type F = {new (s: string): object;
};
某些函数既是构造函数，又可以当作普通函数使用。类型声明可以写成下面这样。
type F = {new (s: string): object;(n?: number): number;
};
)
