@thefourtheye tiene razón al decir que no se puede acceder a estas variables antes de declararlas. Sin embargo, es un poco más complicado que eso.

¿Las variables declaradas con let o const no son izadas? ¿Qué está pasando aquí realmente?

Todas las declaraciones ( var , let , const , function , function* , class ) se "alzan" en JavaScript. Esto significa que si un nombre se declara en un ámbito, en ese ámbito el identificador siempre hará referencia a esa variable en particular:

 x = "global"; // function scope: (function() { x; // not "global" var/let/… x; }()); // block scope (not for `var`s): { x; // not "global" let/const/… x; }

Esto es cierto tanto para los ámbitos de función como de bloque ¹ .

La diferencia entre las declaraciones var / function / function* y las declaraciones let / const / class es la inicialización .
Los primeros se inicializan con undefined o la función (generador) justo cuando se crea el enlace en la parte superior del alcance. Sin embargo, las variables declaradas léxicamente permanecen sin inicializar . Esto significa que se lanza una excepción ReferenceError cuando intenta acceder a ella. Solo se inicializará cuando se evalúe la declaración let / const / class , todo lo anterior (arriba) que se denomina zona muerta temporal .

 x = y = "global"; (function() { x; // undefined y; // Reference error: y is not defined var x = "local"; let y = "local"; }());

Note que a let y; declaración inicializa la variable con undefined como let y = undefined; tendría.

La zona muerta temporal no es una ubicación sintáctica, sino el tiempo entre la creación de la variable (alcance) y la inicialización. No es un error hacer referencia a la variable en el código sobre la declaración, siempre que ese código no se ejecute (por ejemplo, el cuerpo de una función o simplemente un código inactivo), y generará una excepción si accede a la variable antes de la inicialización, incluso si el acceso el código está debajo de la declaración (por ejemplo, en una declaración de función elevada que se llama demasiado pronto).

¿Hay alguna diferencia entre let y const en este asunto?

No, funcionan igual en lo que a elevación se refiere. La única diferencia entre ellos es que una const debe ser y solo puede ser asignada en la parte inicializadora de la declaración ( const one = 1; , tanto const one; y reasignaciones posteriores como one = 2 no son válidas).

_{1: las declaraciones de var todavía funcionan solo en el nivel de función, por supuesto}

Citando la sección de declaraciones let y const de la especificación ECMAScript 6 (ECMAScript 2015),

Las variables se crean cuando se crea una instancia del entorno léxico que las contiene, pero no se puede acceder a ellas de ninguna manera hasta que se evalúe el LexicalBinding de la variable .

Entonces, para responder a su pregunta, sí, let y const hoist pero no puede acceder a ellos antes de que se evalúe la declaración real en tiempo de ejecución.

ES6 presenta las variables Let , que vienen con block level scoping . Hasta ES5 no teníamos block level scoping , por lo que las variables que se declaran dentro de un bloque siempre se hoisted al ámbito de nivel de función.

Básicamente, el Scope se refiere a dónde están visibles sus variables en su programa, lo que determina dónde puede usar las variables que ha declarado. En ES5 tenemos global scope,function scope and try/catch scope , con ES6 también obtenemos el alcance de nivel de bloque usando Let.

• Cuando define una variable con la palabra clave var , se conoce la función completa desde el momento en que se define.

• Cuando define una variable con la declaración let , solo se conoce en el bloque que está definido.

   function doSomething(arr){ //i is known here but undefined //j is not known here console.log(i); console.log(j); for(var i=0; i<arr.length; i++){ //i is known here } //i is known here //j is not known here console.log(i); console.log(j); for(let j=0; j<arr.length; j++){ //j is known here } //i is known here //j is not known here console.log(i); console.log(j); } doSomething(["Thalaivar", "Vinoth", "Kabali", "Dinesh"]);

Si ejecuta el código, podría ver que la variable j solo se conoce en el loop y no antes ni después. Sin embargo, nuestra variable i es conocida en entire function desde el momento en que se define en adelante.

Hay otra gran ventaja al usar let, ya que crea un nuevo entorno léxico y también vincula un valor nuevo en lugar de mantener una referencia anterior.

 for(var i=1; i<6; i++){ setTimeout(function(){ console.log(i); },1000) } for(let i=1; i<6; i++){ setTimeout(function(){ console.log(i); },1000) }

El primer ciclo for siempre imprime el último valor, con let crea un nuevo alcance y vincula valores nuevos que nos imprimen 1, 2, 3, 4, 5 .

En cuanto a constants , funciona básicamente como let , la única diferencia es que su valor no se puede cambiar. En constantes se permite la mutación pero no la reasignación.

 const foo = {}; foo.bar = 42; console.log(foo.bar); //works const name = [] name.push("Vinoth"); console.log(name); //works const age = 100; age = 20; //Throws Uncaught TypeError: Assignment to constant variable. console.log(age);

Si una constante se refiere a un object , siempre se referirá al object , pero el object en sí se puede cambiar (si es mutable). Si desea tener un object inmutable, puede usar Object.freeze([])