JavaScript anonymous function instance analysis_javascript skills

The examples in this article describe the usage of JavaScript anonymous functions. Share it with everyone for your reference. The specific analysis is as follows:

Summary:

This article explains the most basic and important thing in JavaScript - functions. The reason why I wrote this article is because I was asked about it during the interview, and it can be regarded as a refresher.

Let’s take an example first. If you understand it, it means you already understand what this article is about.

Copy code The code is as follows:

var f = (function() {

function f() {return 10;}

return f();

function f() {return 20;}

var f = 30;

})();

console.log(f);

Functions are described in advanced JavaScript programming like this - they can encapsulate any number of statements and can be called and executed anywhere and at any time. I introduced strict mode before. Strict mode has some restrictions on functions:

① The function cannot be named eval or arguments
② You cannot name parameters as eval or arguments
③ There cannot be two named parameters with the same name

If the above situation occurs, it will cause a syntax error and the code cannot be executed.

Function definition

Function definitions are divided into three types

1. Constructor

Copy code The code is as follows:

var fun = new Funciton();

2. Common definition

Copy code The code is as follows:

function fun() {}

3. Functional definition

Copy code The code is as follows:

var fun = function() {};

The function fun can be defined in these three ways.

Parameters

The function does not care how many parameters are passed in, nor what data type the parameters are passed in. Even if the function you define only receives two parameters, you do not necessarily have to pass two parameters when calling this function. You can pass one, three or even no parameters. The reason is that the parameters are represented internally by an array. In the function body, you can access the parameter array through the arguments object, for example

Copy code The code is as follows:

function sayHi() {

alert("Hello " arguments[0] "," arguments[1]);

}

Know how many parameters there are by accessing the length property of the arguments object. The length of the function returns the number of parameters of the function.

Note: All parameters are passed by value, and it is impossible to pass parameters by reference.

Functions cannot be overloaded, they can only be rewritten

If two functions with the same name are defined, the name only belongs to the last defined function, for example:

Copy code The code is as follows:

function add(num) {

return num 100;

}

function add(num) {

return num 200;

}

var result = add(100) //300

Note: The function stops and exits immediately after executing the return statement.

Function types

Functions are divided into two types: named functions and anonymous functions. For example, the following famous function

Copy code The code is as follows:

function fun() {

}

If called, only fun() is needed.

Anonymous functions, as the name suggests, have no function names. For example

function() {}

Function calls are called through function names. How to call anonymous functions? One is to assign the anonymous function to a variable and let the variable serve as the function name. The other is to use () to call, such as the following three methods

1. (function() {return;}());

2. (function() {return;})();

3. function() {return;}();

Example:

Copy code The code is as follows:

(function(x, y) {

​​alert(x y);

})(2,3);

//alert(5)

2 and 3 will be passed as parameters to x and y

Let’s talk about the top example. This example involves closures, which will be discussed later

First define a variable f, and then assign it to an anonymous function. It should be noted here that the definition of all variables in the function will be prepended, so the execution order in the anonymous function is

Copy code The code is as follows:

var f = (function() {

var f = 30;

function f() {return 10;}

function f() {return 20;}

return f();

})();

The outer variable f and the inner variable f are not in the same scope (closure), so they have no influence on each other. ​Because the function cannot be overloaded, the external variable f=(function f() {return 20;})();, so the final output is 20.

I hope this article will be helpful to everyone’s JavaScript programming design.