• 可以用Function来描述

    但是不够精确，一般不会使用

    1
    const fn:Function = () => {}

  • 一般是箭头函数

1
type AFun = (x:number, y:number) => number;

函数声明

类型约束（type constraints）

  • extends
  • TODO

函数泛型

  • 泛型参数

  • 泛型的类型推导

    通过函数入参推断泛型参数的值。

函数签名 signature

类型约束Constraint

可选参数 Optional parameter

  • default parameter

THIS

  • 有this的函数声明
1
2
3
4
5
6
7
8
9
10
11
12
13
14
type Person = {
  name: string;
  sayHi: FnWithThis;
}
type FnWithThis = (this: Person, name:string) => void
const sayHi: FnWithThis = function() {
  console.log('hi ', this.name);
}
const x: Person = {
  name: 'hei',
  sayHi: sayHi
}
x.sayHi('jack');
sayHi.call(x, 'jack');

函数重载 Function overloads

not overrides。

对于同一个函数名称，如果产生不同的入参和返回值，在JS里我们可以这样实现。比如两个值相加。

1
2
3
4
// function add(x:number, y: number):number;
function add (a, b) {
	return a + b;
}

function signaturedesign

函数名，入参，返回值一致。

当新增一个参数时

1
2
3
4
5
6
function add (a, b, c) {
  if (typeof c === 'number') {
    return a + b + c;
  }
	return a + b;
}

So，在ts 里对于函数类型的严谨性，需要重新声明该类型。

1
2
3
4
5
6
// type define for add function
2

// call add
add(1,2);
add(1,2, 3);

重载函数一般通过以下几种方式。

  • 参数类型不同

  • 参数个数不一致

  • 参数顺序

  • 参数默认值

    • 这里有一个理解的问题（就是把字面量理解为类型还是参数默认值，但理解为类型更合适）

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      01  //1声明定义
      02  function disp(x:"Jack",y:number);
      03  function disp(x:"Smith", y: number);
      04  //2实现
      05  function disp(x: any, y: any) {
      06      if ( x === "Jack") {
      07          console.log("Jack = "+y);
      08      }
      09      else if (x === "Smith") {
      10          console.log("Smith = "+y);
      11      }
      12      else {
      13          console.log("未实现");
      14      }
      15  }
      16  disp("Jack", 3);
      17  disp("Smith", 6);

  • 返回值类型不一致

  • 返回值个数不同

c#中的overload

函数重载的最佳实践（不需要重载的情况）

  • 如果返回值一致/ 参数一致，可以把两个或多个重载合为一个。

剩余参数 Rest

实参 argument

形参 parameter

1
2
3
const args = [8, 5] as const; // convert to turple
Math.atan2(...args);
Math.atan2(8, 5);

参数解构destructure