Introduction to javascript functions_basic knowledge

1. Definition and calling of functions
In JavaScript, the most common way to define a function is to call the function statement. The statement is composed of the function keyword, which is followed immediately by:
Ø Function name
Ø A parameter list in parentheses. The parameters are optional and separated by commas
Ø Function body included in curly brackets
Several things to note when using functions:
Ø If there is a return statement in the function body, it returns a value; if not, it returns undefined
Ø JavaScript will not check whether the number of function parameters is correct. If more actual parameters are passed than formal parameters, the excess actual parameters will not be ignored; if less than the number of parameters passed, the formal parameters without passed parameters will be assigned to undefined. In this case Generally, an error will occur when running the program

[Ctrl A Select all Note: If you need to introduce external Js, you need to refresh to execute

]

Running result:
ddxkj
undefined
aaa

ccc
aaa

ccc
aaa

undefined
1.1. Nested functions
JavaScript 1.2 and ECMAScript v3 allow a function definition to appear within another function, which is nesting of functions. It should be noted that ECMAScript v3 does not allow function definitions to appear arbitrarily. They are still restricted to top-level global code and top-level function code, which means that function definitions cannot appear in loops and conditional statements. For example:

[Ctrl A Select all Note:

If you need to introduce external Js, you need to refresh to execute
]

Running result:
10000
1.2. Function() constructor
In ECMAScript v1 and JavaScript 1.1, it is allowed to use Function() and new to dynamically define a function. For example: var f = new Function("x", "y", "return x*y;");
This line of code is almost equivalent to: function f(x,y){return x*y;}
The Function() constructor can accept any number of string parameters. The last parameter is the function body, which can contain any JavsScrpt statement. Use; to separate each line of statements. If the function has no parameters, just a string of function body is enough.
Sometimes the Function() constructor is also called an anonymous function because the function name is not defined.
Use of Function() constructor:
Ø Dynamically create and compile a function. Every time a function is called, the Function() constructor has to compile the function, which becomes a disadvantage. Therefore, the Function() constructor is generally not used in loops or frequently called functions.
Ø Define functions as JavaScript expressions instead of statements. However, in JavaScript, if you want to define a function in an expression instead of a statement, it is more convenient to use function literals.
1.3. Function literal
The syntax of function literal is very similar to the function statement, except that it is used as an expression instead of a statement, and the function name does not need to be specified. Like the function statement and Function() constructor, function literals are also one of the ways to create functions. For example:
Ø function f(x){return x*x;} //function statement
Ø var f = new Funtion("x","return x*x;"); //Function() Constructor
Ø var f = function(x){return x*x;};
Although the function literal creates an unnamed function, you can also specify the function name, which is done when writing the call
itself Recursive functions are very useful. For example:
var f = function fact(x) { if (x <= 1) return 1; else return x*fact(x-1); };
The above code defines an unnamed function, and store its reference in f. It does not create the fact() function, it just allows the function body to use this name without calling itself.

Function literals can be assigned, passed to functions, or even called directly like variables. For example:

[Ctrl A select all Note: <script> //print1返回一个值 function print1(){ return 'ddxkj'; } //print1没有return语句，返回undefined function print2(){ } function print3(str1,str2,str3){ document.write(str1,"<br>"); document.write(str2,"<br>"); document.write(str3,"<br>"); } document.write(print1(),"<br>"); document.write(print2(),"<br>"); print3('aaa','bbb','ccc'); //实参和形参个数相同 print3('aaa','bbb','ccc','ddd','eee'); //实参个数多于形参 print3('aaa','bbb'); //实参个数小于形参 </script>If you need to introduce external Js, you need to refresh to execute <script> function print(a){ function square(x) {return x*x;} document.write(square(a)); } print(100); </script>]<script> var f1 = function(x){return x*x;}; //定义并保存 var f2 = function(x){return x*x;}(5); //直接调用 document.write(f1(10),"<br>"); document.write(f2,"<br>"); </script>
运行结果：
100
25
2. 作为数据的函数
当函数被做为一种数据时，就可以像变量，被赋值、存储在对象属性或数组、传递给函数。
当以如下方式定义一个函数时，function square(x){return x*x;}，定义了一个函数对象，并把这个函数对象赋值给了square。在这里square没有任何意义，不过只是一个对象而已，存储了函数对象。可以将这个函数赋值给其它变量。例如：

<script> function square(x) { return x*x; } var a = square(4); document.write(a,"<br>"); //打印出16 var b = square; var c = b(10); document.write(c,"<br>"); //打印出100 </script>
[Ctrl+A 全选 注:如需引入外部Js需刷新才能执行]

运行结果：
16
100

<script> function add(x,y) { return x + y; } function subtract(x,y) { return x - y; } function multiply(x,y) { return x * y; } function divide(x,y) { return x / y; } function operate(operator, operand1, operand2) { return operator(operand1, operand2); } var i = operate(add, operate(add, 2, 3), operate(multiply, 4, 5)); document.write(i,"<br>"); var operators = new Object( ); operators["add"] = function(x,y) { return x+y; }; operators["subtract"] = function(x,y) { return x-y; }; operators["multiply"] = function(x,y) { return x*y; }; operators["divide"] = function(x,y) { return x/y; }; operators["pow"] = Math.pow; function operate2(op_name, operand1, operand2) { if (operators[op_name] == null) return "unknown operator"; else return operators[op_name](operand1, operand2); } var j = operate2("add", "hello", operate2("add", " ", "world")) var k = operate2("pow", 10, 2) document.write(j,"<br>"); document.write(k,"<br>"); </script>
[Ctrl+A 全选 注:如需引入外部Js需刷新才能执行]

运行结果：
25
hello world
100