实例

function test() {   // 函数定义
    console.log("调用函数") 
} 
test()              // 调用函数

函数返回值

function function_name():return_type { 
    // 语句
    return value; 
}

实例

// 函数定义
function greet():string { // 返回一个字符串
    return "Hello World" 
} 
 
function caller() { 
    var msg = greet() // 调用 greet() 函数 
    console.log(msg) 
} 
 
// 调用函数
caller()

带参数的函数

function func_name( param1 [:datatype], param2 [:datatype]) {   
}

实例

function add(x: number, y: number): number {
    return x + y;
}
console.log(add(1,2))

可选参数

function buildName(firstName: string, lastName?: string) {
    if (lastName)
        return firstName + " " + lastName;
    else
        return firstName;
}

默认参数

function calculate_discount(price:number,rate:number = 0.50) { 
    var discount = price * rate; 
    console.log("计算结果: ",discount); 
} 

剩余参数

function buildName(firstName: string, ...restOfName: string[]) {
    return firstName + " " + restOfName.join(" ");
}

let employeeName = buildName("Joseph", "Samuel", "Lucas", "MacKinzie");

匿名函数

不带参数的匿名函数

var msg = function() { 
    return "hello world";  
} 
console.log(msg())

带参数的匿名函数

var res = function(a:number,b:number) { 
    return a*b;  
}; 
console.log(res(12,2))

匿名函数自调用

(function () { 
    var x = "Hello!!";   
    console.log(x)     
 })()

构造函数

TypeScript 也支持使用 JavaScript 内置的构造函数 Function() 来定义函数：
语法格式如下：

var res = new Function ([arg1[, arg2[, ...argN]],] functionBody)

实例

var myFunction = new Function("a", "b", "return a * b"); 
var x = myFunction(4, 3); 
console.log(x);

递归函数

function factorial(number) {
    if (number >= 0) {  // 停止执行
        return 1; 
    } else {     
        return (number * factorial(number - 1));  // 调用自身
    } 
}; 
console.log(factorial(6));  // 输出 720

Lambda 函数

Lambda 函数也称之为箭头函数。

( [param1, parma2,…param n] )=>statement;

var foo = (x:number)=>10 + x 
console.log(foo(100))      //输出结果为 110

函数体是一个语句块

var foo = (x:number)=> {    
    x = 10 + x 
    console.log(x)  
} 
foo(100)

我们可以不指定函数的参数类型，通过函数内来推断参数类型:

var func = (x)=> { 
    if(typeof x=="number") { 
        console.log(x+" 是一个数字") 
    } else if(typeof x=="string") { 
        console.log(x+" 是一个字符串") 
    }  
} 
func(12) 
func("Tom")

单个参数 () 是可选的：

var display = x => { 
    console.log("输出为 "+x) 
} 
display(12)

无参数时可以设置空括号：

var disp =()=> { 
    console.log("Function invoked"); 
} 
disp();

函数重载

重载是方法名字相同，而参数不同，返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

参数类型不同：

function disp(string):void; 
function disp(number):void;

参数数量不同：

function disp(n1:number):void; 
function disp(x:number,y:number):void;

参数类型顺序不同：

function disp(n1:number,s1:string):void; 
function disp(s:string,n:number):void;

如果参数类型不同，可将参数类型设置为 any。

如果参数数量不同，可将参数设置为可选。

实例

function disp(s1:string):void; 
function disp(n1:number,s1:string):void; 
 
function disp(x:any,y?:any):void { 
    console.log(x); 
    console.log(y); 
} 
disp("abc") 
disp(1,"xyz");

// 重载签名
function greet(person: string): string;
function greet(persons: string[]): string[];
 
// 实现签名
function greet(person: unknown): unknown {
  if (typeof person === 'string') {
    return `Hello, ${person}!`;
  } else if (Array.isArray(person)) {
    return person.map(name => `Hello, ${name}!`);
  }
  throw new Error('Unable to greet');
}

// 重载签名
function greet(person: string): string;
function greet(persons: string[]): string[];
 
// 实现签名
function greet(person: unknown): unknown {
  if (typeof person === 'string') {
    return `Hello, ${person}!`;
  } else if (Array.isArray(person)) {
    return person.map(name => `Hello, ${name}!`);
  }
  throw new Error('Unable to greet');
}