The implementation principle and function of closure and memory leakage

　 In simple terms, the function in the closure , It can also be understood as a phenomenon , That is, a function needs to access variables inside another objective function , We need to define another function in the objective function （ To extend the scope chain down a section , The purpose is to take advantage of js When looking for free variables , Features that will be found up level by level along the scope chain ）, And put this defined function return come out , For external use . In actual development , Closures are mainly used to encapsulate variables , Convergence authority .

What is a closure ?（ Put code ）

var value = 3
    function  bar(){
        // Variables declared by outer functions 
        var value=1;
        var name = 'homey'

        function foo(){
			var value = 2
            console.log(name)
			console.log(value);
            console.log(this.value);
        }
        return foo();
    };
    var bar2=bar;
    // actually bar() Functions are not disposed of by the garbage collection mechanism just because they are executed 
    // That's what closures do , call bar() function , It's going to carry out what's inside foo function ,foo At this point, the outer variables will be accessed 
	bar2();

  If for this ill-defined , It can be seen that my early blog JavaScript Medium this Principle and 6 A detailed explanation of common usage scenarios _ A blog as cool as mushrooms -CSDN Blog

foo（） contain bar（） Closure of internal scopes , Make this scope live... All the time , It won't be disposed of by the garbage collection mechanism , That's what closures do , In order to offer foo（） Quote at any time .

The advantages of closures ：

• It is convenient to call local variables declared in the context
• The logic is tight , You can create another function in a function , It avoids the problem of transmitting parameters

Disadvantages of closures ：

Because of using closures , You can make the function not be destroyed after execution , Keep in Memory in , If you use closures a lot, you can leak memory , Memory consumption is high

The application of closure in practice

function isFirstLoad(){
            var list=[];
            return function(option){
                if(list.indexOf(option)>=0){ // Check whether it exists in the existing array , If there is one, it indicates that it already exists 
                    console.log(' Already exists ')
                }else{
                    list.push(option);
                    console.log(' First incoming '); // No return true, And enter the data this time 
                }
            }
        }

var ifl=isFirstLoad();
ifl("zhangsan"); 
ifl("lisi");
ifl("zhangsan");

You can see , If the outside world wants to visit _list Variable , Only through the functions I define isFirstLoad To visit , I want to visit _list The outside world only provides isFirstLoad This interface . As for how to operate _list, I've defined , All the outside world can do is use my function , Then pass on several different parameters .

Finally, by the way , It's time to define the scope chain , With whom to execute , It doesn't matter when it is executed .

Above excerpts from

The principle and function of closure 、 And memory leaks _AriD_shea The blog of -CSDN Blog _ How closures are implemented

Say the application of a closure in practical development - On the moon - Blog Garden