JavaScript deep understanding of JS closure __js

Source: Internet
Author: User
Tags closure variable scope

scope of a variable

To understand closures, you must first understand JavaScript's special variable scope.

The scope of a variable is nothing more than two kinds: global and local variables.

The special point of the JavaScript language is that the global variable can be read directly from within the function.


JS Code

var n=999;

Function F1 () {
alert (n);
}

F1 (); 999

On the other hand, local variables within a function cannot naturally be read outside the function.

JS Code

Function F1 () {
var n=999;
}

alert (n); Error

Here's a place to be aware that when declaring variables inside a function, you must use the var command. If not, you actually declare a global variable.

JS Code

Function F1 () {
n=999;
}

F1 ();

alert (n); 999

--------------------------------------------------------------------------------------------------------

second, how to read local variables from the outside.

For a variety of reasons, we sometimes need to get local variables within a function. However, as mentioned earlier, this is not possible under normal circumstances and can only be achieved by workaround.

That is, in the interior of the function, define a function.

JS Code

Function F1 () {

n=999;

function F2 () {
alert (n); 999
}

}

In the above code, the function F2 is included within the function F1, when all local variables within F1 are visible to F2. But the reverse is not, F2 internal variables, the F1 is not visible. This is the "chained scope" structure (chain scope) peculiar to the JavaScript language.

The child object looks up the variables of all the parent objects at a level. Therefore, all the variables of the parent object are visible to the child, and the opposite is not true.

Since F2 can read local variables in F1, we can not read the internal variables of the F2 as long as the return value.


JS Code

Function F1 () {

n=999;

function F2 () {
alert (n);
}

return F2;

}

var result=f1 ();

Result (); 999

--------------------------------------------------------------------------------------------------------

third, the concept of closure

The F2 function in the previous section of the code is the closure.

The definition of "closure" (closure) in various professional literature is very abstract and difficult to read. My understanding is that closures are functions that can read internal variables of other functions.

Because in a JavaScript language, only a child function within a function can read a local variable, the closure can be simply understood as "a function defined within a function."

So, in essence, closures are a bridge that connects functions inside and outside functions.

--------------------------------------------------------------------------------------------------------b

Iv. use of closures

Closures can be used in many places. Its maximum use is two, one is the previous mentioned can read the function inside the variable, the other is to keep the values of these variables always in memory.

How to understand this sentence. Take a look at the code below.


JS Code

Function F1 () {

var n=999;

Nadd=function () {n+=1}

function F2 () {
alert (n);
}

return F2;

}

var result=f1 ();

Result (); 999

Nadd ();

Result (); 1000

In this piece of code, result is actually the closure F2 function. It runs two times, the first value is 999, and the second value is 1000. This proves that the local variable n in the function F1 is kept in memory and is not automatically purged after the F1 call.

Why is that so? The reason is that F1 is the parent function of F2, and F2 is assigned to a global variable, which causes F2 to always be in memory, and the presence of F2 depends on F1, so F1 is always in memory and will not be reclaimed by the garbage collection mechanism (garbage collection) after the call has ended.

Another notable part of this code is the "Nadd=function () {n+=1}" line, which first nadd not use the var keyword, so nadd is a global variable, not a local variable. Second, the value of the Nadd is an anonymous function (anonymous functions), and the

The anonymous function itself is also a closure, so the nadd is equivalent to a setter, which can manipulate local variables within the function outside the function.

--------------------------------------------------------------------------------------------------------

Five, use the closure of the attention point

1 because the closure will make the function of the variables are stored in memory, memory consumption is very large, so can not abuse the closure, otherwise it will cause Web page performance problems, in IE may lead to memory leaks. The workaround is to remove all unused local variables before exiting the function.

2 The closure will change the value of the inner variable of the parent function outside the parent function. So, if you use the parent function as an object, using the closure as its common method, and the internal variable as its private property (private value), be careful not to

Change the value of a variable within the parent function.

--------------------------------------------------------------------------------------------------------

VI. Study Questions

If you can understand the operating results of the following code, you should understand the closure mechanism.

JS Code
var name = "the window";
var object = {
Name: "My Object",
Getnamefunc:function () {
return function () {
return this.name;
};
}
};
Alert (Object.getnamefunc () ()); The Window

--------------------------------------------------------------------------------------------------------
JavaScript Closures Example

function Outerfun ()
{
var a=0;
function Innerfun ()
{
a++;
alert (a);
}
}
Innerfun ()

The code above is wrong. The scope of the Innerfun () is called Inside the Outerfun () and it is wrong to invoke it outside the Outerfun ().

Change to the following, which is the closure:

JS Code

function Outerfun ()
{
var a=0;
function Innerfun ()
{
a++;
alert (a);
}
return innerfun; Watch this.
}
var obj=outerfun ();
obj (); Result is 1
obj (); Result is 2
var obj2=outerfun ();
Obj2 (); Result is 1
Obj2 (); Result is 2

What is closure:

When an intrinsic function is referenced outside the scope that defines it, the closure of the internal function is created, and if the intrinsic function references a variable that is located in an external function, the variables are not freed in memory when the external function is called, because the closures require them.

--------------------------------------------------------------------------------------------------------

let's look at an example .

JS Code

function Outerfun ()
{
var a = 0;
alert (a);
}
var a=4;
Outerfun ();
alert (a);

The result is 0,4. Because the VAR keyword is used inside the function to maintain a scope within outfun ().

Then look at the following code:

JS Code

function Outerfun ()
{
No Var
A = 0;
alert (a);
}
var a=4;
Outerfun ();
alert (a);
The result is 0, 0 is really strange, why?

A scope chain is a term that describes a path that can be used to determine the value of a variable. When a=0 is executed, because the VAR keyword is not used, the assignment operation is linked to the Var a=4 along the scope; and change its value.

--------------------------------------------------------------------------------------------------------------- -----------------------------------

If you are not very understanding of JavaScript closures, please see the following reproduced article: (Reprint: http://www.felixwoo.com/archives/247)

One, what is closure.

The official explanation is that a closure is an expression (usually a function) that has many variables and an environment that binds them, and therefore these variables are also part of the expression.
I believe very few people can read this sentence directly, because he describes too academic. In fact, this phrase is in layman's terms:all function in JavaScript is a closure . In general, however, nested function results in a more powerful closure, which is what we call "closures" most of the time. Look at the following code:

function A () { 
 var i = 0; 
 function B () {alert (++i);} 
  return b;
}
var c = A ();
C ();

This code has two features:

1. The function b is nested inside function A;

2, function a returns function B.

The reference relationship is shown in figure:

Related Article

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.