TS function

1. Define and call functions

function fo() {
       //  Function definition 
    console.log(" Call function ") 
} 
fo()              //  Call function 

2. Function with return value

type yes Type of return value ,return The keyword is followed by the result to be returned .

function fo():type{
     
    return value; // The type of the return value needs to be the same as the return value type defined by the function （type） Agreement .
}

3. Functions with parameters

// p1、p2  For the parameter name ,type  Is the parameter type 
function fo( p1 [:type], p2 [:type]) {
     ... }

Example ： When the parameter is fixed , Incoming parameter Too much or The lack of All will report wrong. .

function add(p1: number, p2: number): number {
    
    return p1 + p2;
}
console.log(add(1)); //  error , Parameter missing 
console.log(add(1,2)); //  correct  3
console.log(add(1,2,3)); //  error , Too many parameters 

4. Optional parameters

? Question marks identify optional parameters .

function test(p1: string, p2?: string) {
    
	return p2 ? p1 + " " + p2 : p1;
}
let result1 = test("AAA");                //  correct 
let result2 = test("AAA", "BBB", "CCC");  //  error , Too many parameters 
let result3 = test("AAA", "BBB");         //  correct 

// Optional parameters must follow required parameters .
// If you want to p1 It's optional ,p2 It's a must , Then adjust their position , hold p1 Put it in the back .
// If all are optional parameters , It doesn't matter .

5. Default parameters

After setting the default value of the parameter , If the value of this parameter is not passed in when calling , Use default parameters .

function fo(p1 [:type], p2 [:type] = default_value) {
     ... }

notes ： The parameter cannot be set to both optional and default .

6. The remaining parameters

There is a situation , When you don't know how many parameters to pass to the function , You can use the remaining parameters to define .

Residual parameter syntax , Allow us to pass an indefinite number of parameters as an array .

function fo(p1: string, ...ppp: string[]) {
    
    return p1 + " " + ppp.join(" ");
}
let fos = fo("AAA", "BBB", "CCC", "DDD");

// The last named parameter of the function ppp With ... The prefix , Will become an array of remaining parameters .
// Index value from 0（ Include 0） To ppp.length（ barring ）.

7. Anonymous functions

An anonymous function is a function without a function name .

Anonymous functions are declared dynamically when the program is running , Except that there is no function name , Others are the same as standard functions .

// You can assign an anonymous function to a variable , This expression becomes a function expression .
var res = function([arguments]){
     ... };

7.1 Anonymous functions with no arguments ：

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

7.2 Anonymous functions with parameters ：

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

7.3 Anonymous function self call

Anonymous functions are used after the function is called () that will do ：

(function () {
     
    console.log("Hello!!")     
 })()