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
Document
- 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
Related recommendations: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!