在函数中绑定一个变化的变量，我想要一个名字

Question

I have somethings like:

var i = 0;

var func = function(){
    console.log(i);
};

func(); //0

i++;

func(); //1

I want to have the second console also output ' 0 ', so I change the program like:

var i = 0;

var func = (function(_i){
    return function(){
        console.log(_i);
    };
})(i);

func(); //0

i++;

func(); //0

I know how it works, but is there any name or terms to describe such mechanism?

Answer 1

I've been calling this mechanism "breaking the closure" though I've had arguments in the past with people who insist on calling this technique "closure" .

The reason I call it "breaking" closures is because that's what you're doing.

The classic place where you see this is in solutions for closures in loops:

var hellos = [];

for (var i=0; i < 10; i++) {
    hellos.push(
        (function(j){
            return 'hello ' + j
        })(i)
    );
}

The problem is caused by a closure being created between the outer variable and references to that variable in the inner function (technically the variable is called a "free" variable rather than a closure, "closure" technically refers to the mechanism that captures the variable but in the js community we've ended up calling both things closures). So closure is the cause of the problem. Since the problem is caused by a closure being created I've started referring to the solution as "breaking the closure" .

Note that even though some people call this a closure and you may google for "js closure" to read more about this technique it is ironically not a closure. What it is is simply how functions pass arguments (there's a whole side-argument about how javascript actually pass arguments to functions which you can read here: Why are objects' values captured inside function calls? ). Javascript is a fairly strict pass-by-value language in the same way C is a strict pass-by-value language (C can ONLY pass by value).

When you pass a reference in js (objects, arrays) the function will not get the original reference but rather a copy of the reference. Since it is a reference it obviously points to the same object as the original reference so it is easy to mistakenly believe that javascript passes by reference. But if you try to assign a new object to the passed-in reference you will notice that the original reference does not change. For example:

function foo (x) {
    x = [2,3];
}

var y = [1,2];
foo(y);
console.log(y) // prints [1,2] so foo() did not change y

It is this mechanism that is responsible for breaking the association between the outer variable (in your example that would be i ) and the inner variable ( _i in your example). The name of this mechanism is simply function calling (well, technically it is a subset of function calling - it is how arguments are passed to function calls).

So to recap:

1. I personally call it "breaking the closure"
2. Some people call it "closure" even though it is not a closure (the closure is what they want to avoid instead).

---

Side note: I realize that the original example is about a global variable but in javascript global variables are just a special case of closures - closures are ALWAYS created when you define a function, it's just that when there's no outer function the outer scope is simply the global scope.

Answer 2

It's called a closure. You can read more about them here:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Closures

Answer 3

When passing in a primitive type variable like a string or a number, the value is passed in by value. This means that any changes to that variable while in the function are completely separate from anything that happens outside the function.

if the variable in the scope is not declared, it will search the outer scope, until find it, or to the window scope. if not find, it will the variable global.