在TypeScript中，有两种常见的定义函数方式——函数声明（Function Declaration）和函数表达式（Function Expression）

    1. // 函数声明
    2. function sum(x: number, y: number): number {
    3.   return x + y;
    4. }
    6. //表达式声明
    7. let mySum = function (x: number, y: number): number {
    8.   return x + y;
    9. }

    在调用过程中，输入多余的（或小于要求的）参数，都是不被允许的

    1. // 函数声明
    2. function sum(x: number, y: number): number {
    3.   return x + y;
    4. }
    6. //函数调用，多输入一个参数
    7. sum(1, 2, 3);
    9. //编译出错
    10. - error TS2554: Expected 2 arguments, but got 3.
    12. //函数调用，少输入一个参数
    13. sum(1);
    15. //编译出错
    16. - error TS2554: Expected 2 arguments, but got 1.

    用接口定义函数的形状

    1. interface ISearchFunc {
    2.   //函数声明
    3.   (source: string, substring: string): boolean;
    4. }
    6. let mySearch: ISearchFunc;
    8. //函数实现
    9. mySearch = function (source: string, substring: string): boolean {
    10.   return source.search(substring) !== -1;
    11. }

    可选参数：在函数调用的过程中，为了方便，可用可选参数来实现传入参数个数减少。

    1. //可选参数
    2. function buildName(firstName: string, lastName?: string): string {
    3.   if(lastName){
    4.     return firstName + lastName ;
    5.   }else{
    6.     return firstName ;
    7.   }
    8. }
    10. let tomcat = buildName('tom' , 'cat') ;
    11. //可选参数，lastName
    12. let tomName = buildName('tom') ;

    需要注意的是：可选参数必须在必须参数后面。

    1. //参数默认值
    2. function buildNewName(firstname: string, lastname: string = 'Cat'): string {
    3.   return firstname + ' ' + lastname;
    4. }
    6. //完整调用
    7. let newTom = buildNewName('tom', 'cat');
    9. //使用默认参数
    10. let tomNewName = buildNewName('tom');
    12. //必须参数传undefined
    13. let tomNaN = buildNewName(undefined, 'cat');

    如果存在默认参数，此时就不受【可选参数必须在必需参数后面】的限制了
    剩余参数：可使用...rest方式设置函数的剩余参数

    1. // 函数 ...rest 参数
    2. function push(array: any , ... items:any[]){
    3.   items.forEach(function(item){
    4.     array.push(item) ;
    5.   })
    6. }

    注意：rest参数只能是最后一个参数。
    函数重载：允许一个函数接收不同数量或类型的参数时，做出不同的处理。

    1. function reverse(x: number): number;
    2. function reverse(x: string): string;
    3. function reverse(x: number | string): number | string | void {
    4.   if (typeof x === 'number') {
    5.     return Number(x.toString().split('').reverse().join(''));
    6.   } else if (typeof x === 'string') {
    7.     return x.split('').reverse().join('');
    8.   }
    9. }

    在上述示例中，TypeScript会优先从最前面的函数定义开始匹配，所以多个函数如果有包含关系，需要优先将精确的定义写在前面。