let vs var performance in nodejs and chrome

Question

When I test following code in chrome and nodejs, I get following:

Chrome:

for loop with VAR: 24.058ms
for loop with LET: 8.402ms

NodeJS:

for loop with VAR: 4.329ms
for loop with LET: 8.727ms

As per my understanding, because of block scoping LET is faster in chrome. But can someone help me understand why is it opposite in NodeJS? Or am i missing something?

"use strict";
console.time("for loop with VAR");
for (var i = 0; i < 1000000; i += 1) {
 // Do nothing
}
console.timeEnd("for loop with VAR");

console.time("for loop with LET");
for (let i = 0; i < 1000000; i += 1) {
 // Do nothing
}
console.timeEnd("for loop with LET");` 

PS: Not sure if this is not the ideal way to test performance.

Answer 1

V8 version shipped with node.js 5.10 don't support the temporal dead zone for let bindings.

Chrome instead is using V8 5.0 that support it...but as the vm is not yet optimized to handle TDZ, is normal that for now it's slower (I remember reading people who assert that replacing var with let made the code about 27% slower).

Answer 2

When you do

for (let i = 0; i < 1000000; i += 1) { }

the i value in each loop cycle is a separate reference, which is useful when using the i value in an asynchronous callback. This is slower, but can be faster than alternatives in this usage case.

When instead you use

let j;
for (j = 0; j < 1000000; ++j) { }

you will only have one value reference, and it will be just as fast as with var.

Try the following code

console.time("let i");
for (let i = 0; i < 10000000; ++i) { }
console.timeEnd("let i");
console.time("let j");
let j;
for (j = 0; j < 10000000; ++j) { }
console.timeEnd("let j");
console.time("var k");
for (var k = 0; k < 10000000; ++k) { }
console.timeEnd("var k");

this will give results like

let i: 91ms
let j: 25ms
var k: 27ms

where clearly let is equally fast to var when used correctly.

Also to see the difference in asynchronous behaviour, try

for (let i = 0; i < 3; ++i) {
    setImmediate(() => { console.log(i) });
}
let j;
for (j = 0; j < 3; ++j) {
    setImmediate(() => { console.log(j) });
}
for (var k = 0; k < 3; ++k) {
    setImmediate(() => { console.log(k) });
}

which will output

0
1
2
3
3
3
3
3
3

as in each cycle of the loop for let i the i value is a unique reference, which is what causes the slight overhead, whereas for the other two loops it's the same reference.