Return to Answer

var funcs = []
for (var i = 0; i < 3; i += 1) {
 funcs[i] = function () {
 console.log(i)
 }
}
for (var k = 0; k < 3; k += 1) {
 funcs[k]()
}

var funcs = []
for (let i = 0; i < 3; i += 1) {
 funcs[i] = function () {
 console.log(i)
 }
}
for (var k = 0; k < 3; k += 1) {
 funcs[k]()
}

JavaScript functions "close over" the scope they have access to upon declaration, and retain access to that scope even as variables in that scope change.

var funcs = []
for (var i = 0; i < 3; i += 1) {
 funcs[i] = function () {
 console.log(i)
 }
}
for (var k = 0; k < 3; k += 1) {
 funcs[k]()
}

Each function in the array above closes over the global scope (global, simply because that happens to be the scope they're declared in).

Later those functions are invoked logging the most current value of i in the global scope. That's the magic, and frustration, of closure.

"JavaScript Functions close over the scope they are declared in, and retain access to that scope even as variable values inside of that scope change."

Using let instead of var solves this by creating a new scope each time the for loop runs, creating a separated scope for each function to close over. Various other techniques do the same thing with extra functions.

var funcs = []
for (let i = 0; i < 3; i += 1) {
 funcs[i] = function () {
 console.log(i)
 }
}
for (var k = 0; k < 3; k += 1) {
 funcs[k]()
}

(let makes variables that are block scoped instead of function scoped. Blocks are denoted by curly braces, but in the case of the for loop the initialization variable, i in our case, is considered to be declared in the braces.)

JavaScript functions "close over" the scope they have access to upon declaration, and retain access to that scope even as variables in that scope change.

var funcs = []
for (var i = 0; i < 3; i += 1) {
 funcs[i] = function () {
 console.log(i)
 }
}
for (var k = 0; k < 3; k += 1) {
 funcs[k]()
}

Each function in the array above closes over the global scope (global, simply because that happens to be the scope they're declared in).

Later those functions are invoked logging the most current value of i in the global scope. That's the magic, and frustration, of closure.

"JavaScript Functions close over the scope they are declared in, and retain access to that scope even as variable values inside of that scope change."

Using let instead of var solves this by creating a new scope each time the for loop runs, creating a separated scope for each function to close over. Various other techniques do the same thing with extra functions.

var funcs = []
for (let i = 0; i < 3; i += 1) {
 funcs[i] = function () {
 console.log(i)
 }
}
for (var k = 0; k < 3; k += 1) {
 funcs[k]()
}

(let makes variables block scoped. Blocks are denoted by curly braces, but in the case of the for loop the initialization variable, i in our case, is considered to be declared in the braces.)

var funcs = []
for (var i = 0; i < 3; i += 1) {
 funcs[i] = function () {
 console.log(i)
 }
}
for (var k = 0; k < 3; k += 1) {
 funcs[k]()
}

var funcs = []
for (let i = 0; i < 3; i += 1) {
 funcs[i] = function () {
 console.log(i)
 }
}
for (var k = 0; k < 3; k += 1) {
 funcs[k]()
}

JavaScript functions "close over" the scope they have access to upon declaration, and retain access to that scope even as variables in that scope change.

var funcs = []
for (var i = 0; i < 3; i += 1) {
 funcs[i] = function () {
 console.log(i)
 }
}
for (var k = 0; k < 3; k += 1) {
 funcs[k]()
}

Each function in the array above closes over the global scope (global, simply because that happens to be the scope they're declared in).

Later those functions are invoked logging the most current value of i in the global scope. That's the magic, and frustration, of closure.

"JavaScript Functions close over the scope they are declared in, and retain access to that scope even as variable values inside of that scope change."

Using let instead of var solves this by creating a new scope each time the for loop runs, creating a separated scope for each function to close over. Various other techniques do the same thing with extra functions.

var funcs = []
for (let i = 0; i < 3; i += 1) {
 funcs[i] = function () {
 console.log(i)
 }
}
for (var k = 0; k < 3; k += 1) {
 funcs[k]()
}

(let makes variables that are block scoped instead of function scoped. Blocks are denoted by curly braces, but in the case of the for loop the initialization variable, i in our case, is considered to be declared anew in the braces each time.)

JavaScript functions "close over" the scope they have access to upon declaration, and retain access to that scope even as variables in that scope change.

var funcs = []
for (var i = 0; i < 3; i += 1) {
 funcs[i] = function () {
 console.log(i)
 }
}
for (var k = 0; k < 3; k += 1) {
 funcs[k]()
}

Each function in the array above closes over the global scope (global, simply because that happens to be the scope they're declared in).

Later those functions are invoked logging the most current value of i in the global scope. That's the magic, and frustration, of closure.

"JavaScript Functions close over the scope they are declared in, and retain access to that scope even as variable values inside of that scope change."

Using let instead of var solves this by creating a new scope each time the for loop runs, creating a separated scope for each function to close over. Various other techniques do the same thing with extra functions.

var funcs = []
for (let i = 0; i < 3; i += 1) {
 funcs[i] = function () {
 console.log(i)
 }
}
for (var k = 0; k < 3; k += 1) {
 funcs[k]()
}

(let makes variables that are block scoped instead of function scoped. Blocks are denoted by curly braces, but in the case of the for loop the initialization variable, i in our case, is considered to be declared in the braces.)

var funcs = []
for (var i = 0; i < 3; i += 1) {
 funcs[i] = function () {
 console.log(i)
 }
}
for (var k = 0; k < 3; k += 1) {
 funcs[k]()
}

var funcs = []
for (let i = 0; i < 3; i += 1) {
 funcs[i] = function () {
 console.log(i)
 }
}
for (var k = 0; k < 3; k += 1) {
 funcs[k]()
}

JavaScript functions "close over" the scope they have access to upon declaration, and retain access to that scope even as variables in that scope change.

var funcs = []
for (var i = 0; i < 3; i += 1) {
 funcs[i] = function () {
 console.log(i)
 }
}
for (var k = 0; k < 3; k += 1) {
 funcs[k]()
}

Each function in the array above closes over the global scope (global, simply because that happens to be the scope they're declared in).

Later those functions are invoked logging the most current value of i in the global scope. That's the magic, and frustration, of closure.

"JavaScript Functions close over the scope they are declared in, and retain access to that scope even as variable values inside of that scope change."

Using let instead of var solves this by creating a new scope each time the for loop runs, creating a separated scope for each function to close over. Various other techniques do the same thing with extra functions.

var funcs = []
for (let i = 0; i < 3; i += 1) {
 funcs[i] = function () {
 console.log(i)
 }
}
for (var k = 0; k < 3; k += 1) {
 funcs[k]()
}

(let makes variables that are block scoped instead of function scoped. Blocks are denoted by curly braces, but in the case of the for loop the initialization variable, i in our case, is considered to be declared anew in the braces each time.)

JavaScript functions "close over" the scope they have access to upon declaration, and retain access to that scope even as variables in that scope change.

var funcs = []
for (var i = 0; i < 3; i += 1) {
 funcs[i] = function () {
 console.log(i)
 }
}
for (var k = 0; k < 3; k += 1) {
 funcs[k]()
}

Each function in the array above closes over the global scope (global, simply because that happens to be the scope they're declared in).

Later those functions are invoked logging the most current value of i in the global scope. That's the magic, and frustration, of closure.

"JavaScript Functions close over the scope they are declared in, and retain access to that scope even as variable values inside of that scope change."

Using let instead of var solves this by creating a new scope each time the for loop runs, creating a separated scope for each function to close over. Various other techniques do the same thing with extra functions.

var funcs = []
for (let i = 0; i < 3; i += 1) {
 funcs[i] = function () {
 console.log(i)
 }
}
for (var k = 0; k < 3; k += 1) {
 funcs[k]()
}

(let makes variables that are block scoped instead of function scoped. Blocks are denoted by curly braces, but in the case of the for loop the initialization variable, i in our case, is considered to be declared anew in the braces each time.)