JavaScript anonymous functions imitate block-level scope_javascript skills

Anonymous function

Function is the most flexible object in JavaScript. Here we only explain the use of its anonymous functions.

Anonymous function: It is a function without a function name.

The definition of function, first briefly introduce the definition of function, which can be roughly divided into three ways

The first type: This is also the most conventional one

function double(x){
  return 2 * x;  
}

The second method: This method uses the Function constructor and treats both the parameter list and the function body as strings. This is very inconvenient and is not recommended.

var double = new Function('x', 'return 2 * x;');

The third type:

var double = function(x) { return 2* x; }

Note that the function on the right side of "=" is an anonymous function. After creating the function, the function is assigned to the variable square.

There is no concept of block-level scope in JavaScript. In other words, variables defined in block-level statements are actually created in the containing function (external function) rather than in the statement.

function outputNumber(count){ 
  for(var i=0;i<1000;i++){ 
    alert(i); 
  } 
  alert(i);  //count 
} 

For this function in languages ​​such as Java and C#, the variable i will only be defined in the for loop statement. When the loop ends, i will be destroyed. But in JavaScript, the variable i is defined in the outputNumber() activity object, so it can be accessed inside the function as soon as it is defined. Even if you redeclare the same variable, its value will not be changed.

function outputNumber(count){ 
  for(var i=0;i<1000;i++){ 
    alert(i); 
  } 
  var i;   //重新声明变量 
  alert(i);  //count 
} 

Anonymous functions can be used to imitate block-level scope and avoid this problem. The syntax of anonymous functions used as block-level scope (also called private scope) is as follows:

(function(){ 
   //这是块级作用域 
})() 

The above code definition calls an anonymous function and encloses the function declaration in parentheses, indicating that it is a function expression. Another pair of parentheses following it immediately calls the function.
Whenever you need some variables temporarily, you can use private scope, for example:

function outputNumber(count){ 
  (function(){ 
  for(var i=0;i<1000;i++){ 
    alert(i); 
  })(); 
  alert(i);  //导致一个错误 
} 

In this way, we insert a private scope outside the for loop. Any variables defined in an anonymous function will be destroyed at the end of execution.

This technique is often used outside functions in the global scope to limit adding too many variables and functions to the global scope.

In general, we should try to minimize adding variables and functions to the global scope.

This approach can reduce the problem of closures occupying memory, because there is no reference to the anonymous function, and its scope chain can be destroyed immediately as long as the function is executed.