Declarations of var variables get hoisted – the variable name initialization gets hoisted to the top of the containing function (or, if no function, to the top of the outer block). So var withVar = (function() {throw ‘error!’})() is parsed by the interpreter as var withVar; withVar = (function() {throw ‘error!’})() The same is not … Read more
This happens when you introduce the temporal dead zone to the global scope. As you might know, let declarations are hoisted but left uninitialised. Due to control flow, it can happen that a variable is never initialised: function …() { if (false) example; // would throw a ReferenceError if it was evaluated … // do … Read more
1.: The reason this doesn’t work is (more or less) given on the page you linked: It is an error if there is no global var named by the symbol […] And: […] A lookup is done in the current namespace to see if there is a mapping from the symbol to a var. If … Read more
Let is parallel, (kind of; see below) let* is sequential. Let translates as ((lambda(a b c) … body …) a-value b-value c-value) but let* as ((lambda(a) ((lambda(b) ((lambda(c) … body …) c-value)) b-value)) a-value) and is thus creating nested scope blocks where b-value expression can refer to a, and c-value expression can refer to both … Read more
TL;DR In theory, an unoptimized version of this loop: for (let i = 0; i < 500; ++i) { doSomethingWith(i); } might be slower than an unoptimized version of the same loop with var: for (var i = 0; i < 500; ++i) { doSomethingWith(i); } because a different i variable is created for each … Read more
Scoping rules The main difference is scoping rules. Variables declared by var keyword are scoped to the immediate function body (hence the function scope) while let variables are scoped to the immediate enclosing block denoted by { } (hence the block scope). function run() { var foo = “Foo”; let bar = “Bar”; console.log(foo, bar); … Read more
With var you have a function scope, and only one shared binding for all of your loop iterations – i.e. the i in every setTimeout callback means the same variable that finally is equal to 6 after the loop iteration ends. With let you have a block scope and when used in the for loop … Read more
Do let statements create properties on the global object? According to the spec, no: A global environment record is logically a single record but it is specified as a composite encapsulating an object environment record and a declarative environment record. The object environment record has as its base object the global object of the associated … Read more
let and const have two broad differences from var: They are block scoped. Accessing a var before it is declared has the result undefined; accessing a let or const before it is declared throws ReferenceError: console.log(aVar); // undefined console.log(aLet); // Causes ReferenceError: Cannot access ‘aLet’ before initialization var aVar = 1; let aLet = 2; … Read more
@thefourtheye is correct in saying that these variables cannot be accessed before they are declared. However, it’s a bit more complicated than that. Are variables declared with let or const not hoisted? What is really going on here? All declarations (var, let, const, function, function*, class) are “hoisted” in JavaScript. This means that if a … Read more