JS Closed Packet Understanding

Closure is a major feature of JS, but also a major difficulty. Simply put, a closure means that a function can access variables in the outer scope of its function.

The three main features of closures are:

1. Function Nesting function

2. Internal functions can access variables of external functions

3, parameters and variables will not be recycled.

For example:

1. function Test () {
2. var a=1;
3. return function () {
4. alert (a);
5. }
6. }
7. var try=test ();
8. try (); //Eject the value of a

In this example, the variable A is inaccessible outside of the test method, but inside the test method, an anonymous function is nested, returned by return, variable A in the test scope,

Can be accessed in anonymous functions. And when the test method executes, the memory that the variable a occupies does not release, to achieve the purpose that the nested function can also be accessed.

The function of closures is that private variables and methods can be designed by closing the packet.

For example: Create a Perosn class in Java that contains the private variable name.

2. public class person{
4. private String name=' WY ';
6. Public person (val) {
8. Name=val;
10. }
12. Public void setName(val) {
14. Name=val;
16. }
18. Public String getName() {
20. return name;
22. }
24. }

The ability to create a class similar to Java is implemented in JS:

2. (function () {
4. var name="Wangyu";
6. person=function (val) {
8. Name=val;
10. }
12. Person.prototype.setname=function (val) {
14. Name=val;
16. }
18. Person.prototype.getname=Function () {
20. return name;
22. }
24. })();
26. var person1=new Person ("SJ");
28. Alert (this.name)//undefined because it cannot be accessed outside the function domain
30. Alert (Person1.getname ()); //wangyu

The name inside the function is not accessible externally because it is in the function scope, but can be achieved by creating a person object, calling the person's method.

The purpose of modifying and accessing the name value is similar to a private variable in a Java class that cannot be accessed externally and can only be accessed through a class method.

Let's look at an example of a private variable:

2. var aaa = (function () {
4. var a = 1;
6. function bbb () {
8. a++;
10. alert (a);
12. }
14. function CCC () {
16. a++;
18. alert (a);
20. }
22. return {
24. b:bbb, //json structure
26. C:ccc
28. }
30. })();
32. Alert (AAA.A)//undefined
34. AAA.B (); //2
36. AAA.C () //3

Summarize:

1. Closures are functions that have access to variables in another function scope, and the most common way to create closures is to create another function within one function and access the local variables of the function through another function. The disadvantage of closures is that resident memory increases memory usage and is prone to memory leaks if used improperly.

2, do not have to struggle in the end how to calculate the closure, in fact, you write every function counts as closures, even if the global function, you access the function outside the global variables, is the embodiment of the closure.

JS Closed Packet Understanding