在 JavaScript 中创建闭包时

Question

I want to know that when closures is created in JavaScript

function outerFunc() {
    var a = 2;

    function() {
        console.log(a);
        console.log(b);
    };
    var b = 4;
}

var saveFunc = outerFunc();
saveFunc();

Is closures are created before execution of code or closure is created when outerFunc invoked or closures is created when we write innerFunc or closure is created when innerFunc is return from outerFunc and we store innerFunc with closure in saveFunc?

Answer 1

Think of it this way: "a closure is a thing." Specifically, it is a function() that has been declared within the body of another function. You can pass a reference to that function to allow it to be called, and, when you do, it magically will still have access to the variables (such as a, b in your example) which were available to it. That's the magick of closures.

Answer 2

At the outerFunc() creation time. A closure is created everytime when we create a function.

Please visit this link : Closures

Answer 3

Closures are created at function definition time . So, if you have:

var a = 1;
function foo() {
  console.log(a);
}

This is a closure. It "closes over" the outside variables. In this case a . Honestly, the "closes over" never made sense to me (probably does from a different perspective), so I prefer to think of it this way - a function that has access to the outer scope. In this case a comes from the outer scope.

This may seem a bit weird because a lot of examples and explanations of closures have something like:

 function outer() { var a = 1; return function inner(b) {//<----------- return a + b; // | } // | } // | // | var add1 = outer(); // | // | console.log(add1.name); // "inner" --- console.log(typeof a); // undefined console.log(add1(41)); // 42

Where the explanation is that inner is a closure. It is is created as soon as outer is executed (definition time for inner ) and later returned from outer . The special property of the closure is that retains reference to the variable a which is currently out of scope. This is true but it gives the wrong impression. There doesn't need to be an outside reference in the function for it to be a closure. Even a pure function like:

function add(a, b) {
   return a + b;
}

which doesn't use outside references and is entirely self-contained forms a closure at creation.

In short, any function in JavaScript is a closure and has never not been.

However, this is slightly more academic. As mentioned, the useful property of closures is that they retain references to the scope they are defined in. So, in practice we usually refer to closures only when this property is used - so, in the example with inner and outer - both have formed closures but we'd focus on inner because it actually uses the outer scope.

Answer 4

When an inner function uses the outer function's variable, then closer is created in javascript.

 // Closure is not created example function addSquares(a, b) { function square(x) { return x * x; } return square(a) + square(b); } // Closure is created example function addSquares(a, b) { function square(x) { return a * x; } return square(a) + square(b); }