JavaScript closure inside loops – simple practical example

ID : 179

viewed : 90

Tags : javascriptloopsclosuresjavascript

Top 5 Answer for JavaScript closure inside loops – simple practical example

vote vote

96

Well, the problem is that the variable i, within each of your anonymous functions, is bound to the same variable outside of the function.

ES6 solution: let

ECMAScript 6 (ES6) introduces new let and const keywords that are scoped differently than var-based variables. For example, in a loop with a let-based index, each iteration through the loop will have a new variable i with loop scope, so your code would work as you expect. There are many resources, but I'd recommend 2ality's block-scoping post as a great source of information.

for (let i = 0; i < 3; i++) {   funcs[i] = function() {     console.log("My value: " + i);   }; } 

Beware, though, that IE9-IE11 and Edge prior to Edge 14 support let but get the above wrong (they don't create a new i each time, so all the functions above would log 3 like they would if we used var). Edge 14 finally gets it right.


ES5.1 solution: forEach

With the relatively widespread availability of the Array.prototype.forEach function (in 2015), it's worth noting that in those situations involving iteration primarily over an array of values, .forEach() provides a clean, natural way to get a distinct closure for every iteration. That is, assuming you've got some sort of array containing values (DOM references, objects, whatever), and the problem arises of setting up callbacks specific to each element, you can do this:

var someArray = [ /* whatever */ ]; // ... someArray.forEach(function(arrayElement) {   // ... code code code for this one element   someAsynchronousFunction(arrayElement, function() {     arrayElement.doSomething();   }); }); 

The idea is that each invocation of the callback function used with the .forEach loop will be its own closure. The parameter passed in to that handler is the array element specific to that particular step of the iteration. If it's used in an asynchronous callback, it won't collide with any of the other callbacks established at other steps of the iteration.

If you happen to be working in jQuery, the $.each() function gives you a similar capability.


Classic solution: Closures

What you want to do is bind the variable within each function to a separate, unchanging value outside of the function:

var funcs = [];  function createfunc(i) {   return function() {     console.log("My value: " + i);   }; }  for (var i = 0; i < 3; i++) {   funcs[i] = createfunc(i); }  for (var j = 0; j < 3; j++) {   // and now let's run each one to see   funcs[j](); }

Since there is no block scope in JavaScript - only function scope - by wrapping the function creation in a new function, you ensure that the value of "i" remains as you intended.

vote vote

89

Try:

var funcs = [];        for (var i = 0; i < 3; i++) {      funcs[i] = (function(index) {          return function() {              console.log("My value: " + index);          };      }(i));  }    for (var j = 0; j < 3; j++) {      funcs[j]();  }

Edit (2014):

Personally I think @Aust's more recent answer about using .bind is the best way to do this kind of thing now. There's also lo-dash/underscore's _.partial when you don't need or want to mess with bind's thisArg.

vote vote

76

Another way that hasn't been mentioned yet is the use of Function.prototype.bind

var funcs = {};  for (var i = 0; i < 3; i++) {    funcs[i] = function(x) {      console.log('My value: ' + x);    }.bind(this, i);  }  for (var j = 0; j < 3; j++) {    funcs[j]();  }

UPDATE

As pointed out by @squint and @mekdev, you get better performance by creating the function outside the loop first and then binding the results within the loop.

function log(x) {    console.log('My value: ' + x);  }    var funcs = [];    for (var i = 0; i < 3; i++) {    funcs[i] = log.bind(this, i);  }    for (var j = 0; j < 3; j++) {    funcs[j]();  }

vote vote

70

Using an Immediately-Invoked Function Expression, the simplest and most readable way to enclose an index variable:

for (var i = 0; i < 3; i++) {        (function(index) {            console.log('iterator: ' + index);          //now you can also loop an ajax call here           //without losing track of the iterator value:   $.ajax({});            })(i);    }

This sends the iterator i into the anonymous function of which we define as index. This creates a closure, where the variable i gets saved for later use in any asynchronous functionality within the IIFE.

vote vote

55

Bit late to the party, but I was exploring this issue today and noticed that many of the answers don't completely address how Javascript treats scopes, which is essentially what this boils down to.

So as many others mentioned, the problem is that the inner function is referencing the same i variable. So why don't we just create a new local variable each iteration, and have the inner function reference that instead?

//overwrite console.log() so you can see the console output console.log = function(msg) {document.body.innerHTML += '<p>' + msg + '</p>';};  var funcs = {}; for (var i = 0; i < 3; i++) {     var ilocal = i; //create a new local variable     funcs[i] = function() {         console.log("My value: " + ilocal); //each should reference its own local variable     }; } for (var j = 0; j < 3; j++) {     funcs[j](); }

Just like before, where each inner function outputted the last value assigned to i, now each inner function just outputs the last value assigned to ilocal. But shouldn't each iteration have it's own ilocal?

Turns out, that's the issue. Each iteration is sharing the same scope, so every iteration after the first is just overwriting ilocal. From MDN:

Important: JavaScript does not have block scope. Variables introduced with a block are scoped to the containing function or script, and the effects of setting them persist beyond the block itself. In other words, block statements do not introduce a scope. Although "standalone" blocks are valid syntax, you do not want to use standalone blocks in JavaScript, because they don't do what you think they do, if you think they do anything like such blocks in C or Java.

Reiterated for emphasis:

JavaScript does not have block scope. Variables introduced with a block are scoped to the containing function or script

We can see this by checking ilocal before we declare it in each iteration:

//overwrite console.log() so you can see the console output console.log = function(msg) {document.body.innerHTML += '<p>' + msg + '</p>';};  var funcs = {}; for (var i = 0; i < 3; i++) {   console.log(ilocal);   var ilocal = i; }

This is exactly why this bug is so tricky. Even though you are redeclaring a variable, Javascript won't throw an error, and JSLint won't even throw a warning. This is also why the best way to solve this is to take advantage of closures, which is essentially the idea that in Javascript, inner functions have access to outer variables because inner scopes "enclose" outer scopes.

Closures

This also means that inner functions "hold onto" outer variables and keep them alive, even if the outer function returns. To utilize this, we create and call a wrapper function purely to make a new scope, declare ilocal in the new scope, and return an inner function that uses ilocal (more explanation below):

//overwrite console.log() so you can see the console output console.log = function(msg) {document.body.innerHTML += '<p>' + msg + '</p>';};  var funcs = {}; for (var i = 0; i < 3; i++) {     funcs[i] = (function() { //create a new scope using a wrapper function         var ilocal = i; //capture i into a local var         return function() { //return the inner function             console.log("My value: " + ilocal);         };     })(); //remember to run the wrapper function } for (var j = 0; j < 3; j++) {     funcs[j](); }

Creating the inner function inside a wrapper function gives the inner function a private environment that only it can access, a "closure". Thus, every time we call the wrapper function we create a new inner function with it's own separate environment, ensuring that the ilocal variables don't collide and overwrite each other. A few minor optimizations gives the final answer that many other SO users gave:

//overwrite console.log() so you can see the console output console.log = function(msg) {document.body.innerHTML += '<p>' + msg + '</p>';};  var funcs = {}; for (var i = 0; i < 3; i++) {     funcs[i] = wrapper(i); } for (var j = 0; j < 3; j++) {     funcs[j](); } //creates a separate environment for the inner function function wrapper(ilocal) {     return function() { //return the inner function         console.log("My value: " + ilocal);     }; }

Update

With ES6 now mainstream, we can now use the new let keyword to create block-scoped variables:

//overwrite console.log() so you can see the console output console.log = function(msg) {document.body.innerHTML += '<p>' + msg + '</p>';};  var funcs = {}; for (let i = 0; i < 3; i++) { // use "let" to declare "i"     funcs[i] = function() {         console.log("My value: " + i); //each should reference its own local variable     }; } for (var j = 0; j < 3; j++) { // we can use "var" here without issue     funcs[j](); }

Look how easy it is now! For more information see this answer, which my info is based off of.

Top 3 video Explaining JavaScript closure inside loops – simple practical example

Related QUESTION?