Let vs. Var en JavaScript: desmitificando el alcance y las zonas muertas temporales

Introducida en ECMAScript 6, la declaración let ha generado confusión entre los desarrolladores , particularmente en qué se diferencia de la palabra clave var establecida. Este artículo profundiza en los matices entre estas dos declaraciones de variables, destacando sus reglas de alcance y mejores casos de uso.

Alcance

La distinción fundamental radica en su comportamiento de alcance. Las variables declaradas con var están restringidas a la función en la que están definidas (alcance de la función), mientras que las variables let están confinadas al bloque dentro del cual están encerradas (alcance del bloque). Esto significa permitir que las variables tengan un alcance mucho más limitado, evitando que interactúen con variables definidas fuera de su bloque inmediato.

Ejemplo:

function run() {
  var foo = "Foo";
  let bar = "Bar";

  console.log(foo, bar); // "Foo Bar"

  {
    var moo = "Mooo"
    let baz = "Bazz";
    console.log(moo, baz); // "Mooo Bazz"
  }

  console.log(moo); // "Mooo"
  console.log(baz); // ReferenceError
}

run();

En el ejemplo anterior, la variable var moo permanece accesible incluso fuera de su bloque, mientras que la variable let baz arroja un ReferenceError cuando se accede fuera de su bloque.

Temporal Zonas muertas

Otra diferencia son las zonas muertas temporales (TDZ). Para las variables let, existe una TDZ desde el punto de declaración hasta el final del bloque en el que están definidas. Durante este período, acceder a una variable let sin inicialización genera un error de referencia.

Ejemplo :

function test() {
  console.log(foo); // ReferenceError
  let foo = "Bar";
}

test();

En este código, acceder a la variable let foo antes de que se inicialice da como resultado un error de referencia debido a la TDZ.

Cuándo usar Let frente a Var

En general, prefiera usar let para variables dentro de bloques para evitar contaminar el alcance global y evitar colisiones de nombres de variables. Var sigue siendo útil para variables a las que se debe acceder a través de múltiples bloques o funciones.