typescript笔记（六）
一、函数
语法：
function function_name()
{
// 执行代码
}
例如：
function fab(){
console.log(9);
}
fab();
2)、函数调用：
语法：
function_name()
例如：
function fab(){ 定义函数
console.log(9);
}
fab(); 调用函数
3）、函数返回值：
语法：
function function_name():return_type {
// 语句
return value;
}
注意：return_type 是返回值的类型。
return 关键词后跟着要返回的结果。
一个函数只能有一个 return 语句。
返回值的类型需要与函数定义的返回类型(return_type)一致。
例如：
function Gree():string{
return "hello";
}
function Call(){
var msg = Gree();
console.log(msg);
}
Call();
3)、带参数函数
语法：
function func_name( param1 [:datatype], param2 [:datatype]) {
}
param1、param2 为参数名。
datatype 为参数类型。
例如：
function add(x : number ,y : number):number{
return x + y;
}
console.log(add(1,2)); //3
4）、可选参数
在 TypeScript 函数里，如果我们定义了参数，则我们必须传入这些参数，除非将这些参数设置为可选，可选参数使用问号标识 ？。
例如：
function hebei(one: string, two: string) {
return one + " " + two;
}
// let sjz1 = hebei("Bob"); // 错误，缺少参数
// let sjz2 = hebei("Bob", "Adams", "Sr."); // 错误，参数太多了
let sjz3 = hebei("Bob", "Adams"); // 正确
console.log(sjz3)
可选参数
function hebei(one: string, two?: string) {
return one + " " + two;
}
let sjz1 = hebei("Bob"); // 正确
let sjz2 = hebei("Bob", "Adams", "Sr."); // 错误，参数太多了
let sjz3 = hebei("Bob", "Adams"); // 正确
console.log(sjz1,sjz2,sjz3)
5）、默认参数：调用函数的时候，如果不传入该参数的值，则使用默认参数
语法：
function function_name(param1[:type],param2[:type] = default_value) {
}
注意：参数不能同时设置为可选和默认。
例如：
function calculate_discount(price:number,rate:number = 0.50) {
var discount = price * rate;
console.log("计算结果: ",discount);
}
calculate_discount(1000) //500
calculate_discount(1000,0.30) //300
6）、剩余参数：我们不知道要向函数传入多少个参数，这时候我们就可以使用剩余参数来定义。
剩余参数语法允许我们将一个不确定数量的参数作为一个数组传入。
例如：
function ad(...num:number[]){
var i ;
var sum : number = 0;
for(i=0;i<num.length;i++){
sum = sum +num[i];
}
console.log("合为",sum)
}
ad(1,2,3);
ad(10,10,10,10,10) //6 50
7)、匿名函数是一个没有函数名的函数。
语法：
var res = function( [arguments] ) { ... }
例如：
不带参数的匿名函数
var msg = function (){ //将匿名函数赋值给一个变量msg
return "hello";
}
console.log(msg()); //hello
带参数的匿名函数
var res = function(a:number,b:number){
return a*b;
}
console.log(res(2,3)); //6
匿名函数自调用
(function(){
var x = "hello";
console.log(x) //hello
})()
8）、构造函数
语法：
var res = new Function( [arguments] ) { ... })
例如：
var my = new Function("a","b","return a*b")
var x = my(1,3);
console.log(x);
9）、递归函数在函数内调用函数本身。
例如：
function fa(number){
if(number <= 0){
return 1;
}else{
return (number *fa(number -1));
}
}
console.log(fa(6)) //720
10）、箭头函数也称之Lambda 函数
语法：
( [param1, parma2,…param n] )=>statement;
例如：
var foo = (x:number)=>10 + x;
console.log(foo(100)); //110
语句块：
( [param1, parma2,…param n] )=> {
// 代码块
}
例如：
var fo = (x :number)=>{
x = 10+x;
console.log(x); //110
}
fo(100);
不指定函数的参数类型，通过函数内来推断参数类型:
例如：
var func = (x)=> {
if(typeof x=="number") {
console.log(x+" 是一个数字")
} else if(typeof x=="string") {
console.log(x+" 是一个字符串")
}
}
func(12)
func("Tom")
单个参数 () 是可选的：
例如：
var dis = x =>{
console.log(x); //12
}
dis(12);
无参数时可以设置空括号：
例如：
var diss = ()=>{
console.log("Function invoked"); //Function invoked
}
diss()
11)、函数重载重载是方法名字相同，而参数不同，返回类型可以相同也可以不同。
每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
参数类型不同：
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 disa(s1:string):void;
function disa(n1:number,s1:string):void;
function disa(x:any,y?:any):void{
console.log(x)
console.log(y) //输出结果：abc undefined 1 xyz
}
disa("abc")
disa(1,"xyz");
