What is a js closure? Understanding js closures (with code)

closure in js means that function variables can be saved within the function scope, so it seems that the function "wraps" the variable. According to the definition, the function containing the variable is a closure.

The operating environment of this tutorial: windows7 system, javascript version 1.8.5, Dell G3 computer.

Initial definition

闭包(closure)，是指函数变量可以保存在函数作用域内，因此看起来是函数将变量“包裹”了起来。
//根据定义，包含变量的函数就是闭包
function foo() {
    var a = 0;
}
cosole.log(a) 
// Uncaught ReferenceError: a is not defined

"JavaScript Advanced Programming" definition of closure

Closure refers to the right to Functions that access variables in the scope of another function

 //根据《JavaScript高级程序设计》，访问上层函数的作用域的内层函数就是闭包
function foo() {
    var a = 2;
    function bar() {
        console.log(a);
    }
    bar();
}
foo();

"The Definitive Guide to JavaScript" defines closures

Function objects can be related to each other through scope chains, Variables inside the function body can be saved in the function scope, which is a closure.

 var global = "global scope"; //全局变量
function checkscope() {
    var scope = "local scope"; //局部变量
    function f() {
        return scope; //在作用域中返回这个值
    };
    return f();
}
checkscope(); // 返回 "local scope"

Strictly speaking, closures need to meet three conditions:

[1] Access scope;

[2] Function nesting;

[3] Being called outside the scope
Some people think that only condition 1 is met, so IIFE is a closure; some people think that conditions 1 and 2 are met, so the nested function is closed package; some people think that all three conditions are met, so functions called outside the scope are closures

Why do we need closures, what are the uses of js closures

First look at an example, let's implement a counter.

var counter = 0;
function add() {
   return counter += 1;
}
add();
add();
add();// 计数器现在为 3

Now we have achieved our goal, but here comes the problem. Any function in the code can change the value of counter at will, so this counter is not perfect. Then wouldn’t it be better if we put the counter in the add function?

function add() {
    var counter = 0;
    return counter += 1;
} 
add();
add();
add();// 本意是想输出 3, 但输出的都是 1

So if we do this, every time the add function is called, the value of counter will be initialized to 0, which still fails to achieve our purpose.

How to use closures

So at this time we have to use closures to solve this problem. Let’s look at the code first.

var add = (function () {
    var counter = 0;
    return function () {return counter += 1;}
})();
add();
add();
add();// 计数器为 3

At this time we have perfectly implemented the counter. This section is very concise and can be split into the following equivalent code.

function outerFunction () {
     var counter = 0;
     function innerFunction (){
         return counter += 1;
     }
     return innerFunction;
}
var add = outerFunction();
add();
add();
add();// 计数器为 3

The add at this time forms a closure. A closure consists of two parts, a function and the environment in which the function is created. The environment is composed of local variables in the environment. For the closure add, it consists of the function innerFunction and the variable counter, so add can access the variable counter at this time.

Things to note when using closures

Because closures carry the scope of the function that contains them, they will occupy more memory than other functions. It is therefore possible to manually dereference the anonymous function in order to free the memory.

function f2(){
    var n=22;
    var nAdd=function(){n++};
    return function(){
        return {
            n:n,
            nAdd:nAdd
        }
    }
}
//result2就是创建了一个匿名函数
var result2=f2();
//调用函数
console.log(result2());
result2().nAdd();
console.log(result2());
//解除对匿名函数的引用，以便释放内存
result2=null;

Related recommendations:

Using JS closures

Simple understanding of JS closures

javascript in-depth understanding of js closure

The above is the detailed content of What is a js closure? Understanding js closures (with code). For more information, please follow other related articles on the PHP Chinese website!