Let you learn JS closures in minutes

Closure is an important concept in Javascript. For beginners, closure is a very abstract concept, especially the definition given by the ECMA specification. Without practical experience, it is difficult to understand it from the definition. Therefore, this article will not describe the concept of closure in a long way, but will go directly to the practical information so that you can learn closure in minutes!

1 Closures at a glance

When I come into contact with a new technology, the first thing I do is to find its demo code. For us, looking at code can better understand the essence of a thing than natural language. In fact, closures are everywhere. For example, the core codes of jQuery and zepto are all included in a large closure, so I will write the simplest and most primitive closure first so that you can generate closures in your brain. Picture:

function A(){    function B(){
       console.log("Hello Closure!");
    }    return B;
}var C = A();
C();//Hello Closure!

This is the simplest closure.

After having a preliminary understanding, let’s briefly analyze how it is different from ordinary functions. The above code is translated into natural language as follows:

(1) Define ordinary function A

(2) Define the ordinary function B

in A (3) Return B

in A (4) Execute A, and assign the return result of A to the variable C

( 5) Execute C

Summarize these 5 steps into one sentence:

The internal function B of function A is referenced by a variable c outside function A.

Reprocess this sentence and it becomes the definition of closure:

When an internal function is referenced by a variable outside its external function, it A closure is formed.

So, when you perform the above 5 steps, you have already defined a closure!

This is closure.

2 The purpose of closure

Before understanding the function of closure, let’s first understand the GC mechanism in Javascript:

In Javascript, if an object is no longer referenced, then the object will be recycled by GC, otherwise the object will always be saved in memory.

In the above example, B is defined in A, so B depends on A, and the external variable C refers to B, so A is indirectly referenced by C.

In other words, A will not be recycled by GC and will always be stored in memory. In order to prove our reasoning, the above example is slightly improved:

function A(){    var count = 0;    function B(){
       count ++;
       console.log(count);
    }    return B;
}var C = A();
C();// 1C();// 2C();// 3

When we need to define some variables in the module and want these variables to be kept in memory When it is in the module but will not "pollute" the global variables, you can use closures to define this module.

3 High-end writing method

The above writing method is actually the most primitive writing method, but in actual applications, closures and anonymous functions will be used together. The following is a commonly used way to write a closure:

(function(document){    var viewport;    var obj = {
        init:function(id){
           viewport = document.querySelector("#"+id);
        },
        addChild:function(child){
            viewport.appendChild(child);
        },
        removeChild:function(child){
            viewport.removeChild(child);
        }
    }
    window.jView = obj;
})(document);

The function of this component is to initialize a container, and then you can add sub-containers to the container or remove a container.

The function is very simple, but another concept is involved here: executing the function immediately. A brief understanding is enough. What needs to be understood is how this writing method implements the closure function.

The above code can be split into two parts: (function(){}) and (), the first () is an expression, and this expression itself is an anonymous function, so add () after this expression. Indicates the execution of this anonymous function.

So the execution process of this code can be decomposed as follows:

var f = function(document){    var viewport;    var obj = {
        init:function(id){
            viewport = document.querySelector("#"+id);
        },
        addChild:function(child){
            viewport.appendChild(child);
        },
        removeChild:function(child){
            viewport.removeChild(child);
        }
    }
    window.jView = obj;
};
f(document);

It seems that the shadow of closure is seen in this code, but there is no return value in f , it seems that it does not meet the conditions for closure. Pay attention to this code:

window.jView = obj;

obj is an object defined in function f. This object defines a series of methods to execute window. jView = obj defines a variable jView in the window global object and points this variable to the obj object, that is, the global variable jView refers to obj. And the function in the obj object refers to the variable viewport in function f, so in function f The viewport will not be recycled by GC, and the viewport will always be saved in memory, so this writing method meets the conditions of closure.

4 Simple summary

This is the simplest understanding of closure. Of course, closure has a deeper understanding, which is much more involved. , you need to understand the execution context, activation object, and operating mechanism of scope and scope chain of JS. But as a beginner, you don’t need to understand these for now. After you have a simple understanding, you must use it in actual projects. When you use it more, you will naturally have a deeper understanding of closures!