Further understanding of js closures

The content shared with you in this article is about further understanding of js closures. The content is very good. Friends in need can refer to it.

The concept of closure has been confusing to me since I started learning JS a few months ago

I understood it before, but then I didn’t use it for a long time Just forgot

Closure: In layman’s terms, what most people accept is that a function has the right to use local variables in another function

I see a lot of differences

Use the simplest code to express

function out(){

var age=21;

function inner(){
 
 console.log(age);

}

return inner;

}

var fn=out();
 fn(); //22

Very consistent with the concept

I think closure is reflecting the scope

The inner function is defined inside the out function

So console(age);

will use the variable search mechanism. First, search within the scope of your own (inner) function. If not found, go to Find

in the out function scope and then output. If not found in out, it will look for

in a larger scope. Until the scope of the window, the lower-level scope can be accessed upwards, but the upper-level scope cannot be accessed downwards

Scope refers to

{ }

And JS does not have block-level scope

for(var i=0;i<5;i){

console.log(i);// 1 2 3 4 5

}

cosole.log(i );//5

i will not be destroyed just because the for loop is out.

This should be noted

Okay, I talked about a little bit about scope. Now back to closures

The core of closures is return. Just look at the code and you will know.

My understanding is that return returns the function body of inner and the scope that inner can access!

So inner can be accessed anywhere age

Example:

function test(){
 var age=23;
 var fn=out();
 fn(); //21
 
 }
 
 test();//21

It gets 21 instead of 22 because the function body and scope are returned together Then the nearest scope is the out function scope.

Even if age is defined in the test function, it cannot be overwritten because the existing scopes are different

It returns the scope, so it accesses all the variables in that scope and has nothing to do with the scope where your function is now.

Closure is actually a This phenomenon is that everyone who plays DNF is painting pictures and selling materials to make money. This phenomenon is called moving bricks

To sum up: it has to do with the scope of the function you define, and the role of the function you execute. Domain-independent

Contrary to this, this has nothing to do with definition time and is related to execution time. Compare memory

So if you don’t understand it well Closure

Then you can understand it like me

What is returned is the function itself and the scope that the function can access

Give one commonly used one

Closure Tab bar switching

          
  
 
 
1
 
2
 
3
 
4
 
5
 
6
 
 
   

Whenever the for loop executeslist[i].onmouseover, the function will be executed immediately and the current variable i is passed in

Return a function. This forms a closure. Return the function and the scope that the function can access.

Wheneveronmouseoveris triggered, the returned function will be executed.

Then execute the for loop in the generation function to clear all li'sclassName

This sentence is the most important when executing list[n]. Thenhere is thei## passed in when definingonmouseover

# Because the function is executed immediately when it is defined andiis passed to the anonymous function. Thisiis within the scope of the anonymous function

Eachonmouseoversaves its owni

, so when triggeredOnmouseoverallows li to access thei

that was previously saved in the scope, thus realizing the need to change the background color of someone

Understanding of actual parameters, formal parameters and closures of js functions

The above is the detailed content of Further understanding of js closures. For more information, please follow other related articles on the PHP Chinese website!