Diferencias entre var, let y const en Javascript

A simple vista, esas palabras clave parecen iguales, ¿verdad? Pero en realidad, entender la diferencia entre var, let y const puede marcar la diferencia entre un código limpio y uno lleno de bugs. Muchas veces los programadores novatos se confunden con cuál escoger en cada situación —y eso termina generando comportamientos raros o errores difíciles de detectar. La razón está en cómo cada uno maneja el alcance, la reasignación y esa memoria que usan en segundo plano. Esos detalles son clave para hacer tu código más seguro y fácil de mantener.

En resumidas cuentas: saber cuándo usar var, let o const no solo te hace mejor desarrollador; también te ahorra dolores de cabeza cuando los proyectos se complican.

¿Por qué es importante entender estas diferencias?

Porque si tienes claro cómo funcionan estas declaraciones, evitas errores comunes y logras que tu código sea más predecible. Por ejemplo: muchos todavía usan var porque “es lo tradicional”, sin darse cuenta de que tiene un alcance de función —lo cual puede ser un problema en bloques como bucles o condicionales. La variable puede terminar accesible donde no debería.

Luego llegaron let y const con ES6 para poner las cosas en su lugar. La gran pregunta es: ¿cuándo usar cada una? La diferencia principal radica en cómo gestionan el alcance (de bloque o de función), si pueden cambiarse o no… Y entender esas sutilezas ayuda a escribir código más legible, seguro… ¡y menos propenso a fallos!

Un poco de historia sobre var

Var nació desde los primeros días del lenguaje. En aquella época era la opción predilecta para declarar variables que podían cambiar durante la ejecución del programa. Sin embargo —y esto es importante— tiene una limitación fuerte: su alcance es de función (function scope).

¿Eso qué significa? Que si declaras algo con var dentro de un if o un bucle… esa variable no solo vive allí sino en toda la función (o global). Eso puede causar sorpresas desagradables si no estás atento. Aunque var tiene esa familiaridad por ser viejo conocido, hoy ya hay mejores opciones.

El alcance y la mutabilidad de var

¿Alguna vez has declarado una variable con var dentro de un ciclo y luego te sorprendió verla fuera del mismo? Pues pasa porque var no respeta el alcance del bloque; solo mira hacia arriba hasta llegar a la función completa.

Mira este ejemplo:

if (true) {
  var mensaje = "Hola desde var";
}
console.log(mensaje); // Funciona y muestra: "Hola desde var"

Aunque esté dentro del if, esa variable sigue viva afuera. Eso puede ser útil a veces —pero también peligroso si no lo quieres así— porque puedes terminar usando variables donde no deberías.

Y otra cosa importante: var permite re-asignar sin problema alguno. Puedes cambiar su valor tantas veces quieras sin restricciones.

¿Por qué considerar let?

Aquí llega lo bueno: let llegó para poner orden en ese caos. Tiene un comportamiento mucho más lógico —su alcance— es solo del bloque donde fue declarado (como adentro de un ciclo o condicional).

Veamos otro ejemplo:

if (true) {
  let saludo = "Hola con let";
}
console.log(saludo); // Error: saludo no definido

Esto genera error porque saludo solo existe dentro del bloque if. Así evitamos esas variables “que se cuelan” por todos lados sin quererlo.

Además, let también permite reasignar valores varias veces igualito a var; simplemente su alcance ahora sí está restringido al bloque donde fue creada.

Mutabilidad en let vs inmutabilidad en const

Mientras que con let puedes cambiar el valor tantas veces como quieras —por ejemplo—:

let contador = 0;
contador = 5; // perfecto

Con const pasa lo opuesto:

const PI = 3.1416;
// PI = 3.14; // Esto sería error

Pero ojo: cuando declaramos objetos o arreglos con const… podemos modificar sus propiedades o elementos internos sin problema alguno:

const persona = { nombre: "Ana" };
persona.nombre = "María"; // Esto funciona perfectamente

Lo importante aquí es entender que la referencia es fija —no podemos volver a asignar toda la variable— pero sí modificar su contenido interno si queremos.

Recomendaciones prácticas para decidir cuándo usar cada uno

¿En qué casos conviene cada uno? Aquí unos tips rápidos:

• Usa var sólo si necesitas compatibilidad antigua (cosa rara hoy día).
• Prefiere let cuando planeas reasignar valores dentro de bloques específicos.
• Escoge const siempre que puedas mantener algo fijo —esto aporta seguridad extra al código.

Un mantra sencillo sería: si sabes que esa variable NO va a cambiar nunca más después de crearla… mejor usa const. Si necesitas variarla durante el flujo… let será tu amigo favorito.

Tabla rápida comparativa

Este cuadro ayuda mucho para tener claro cuándo usar cada uno según tus necesidades concretas.

Cómo evitar dolores de cabeza al usarlos

¿Has tenido problemas por variables accesibles donde no debían estar? Aquí algunos consejos útiles:

• Siempre usa const para variables que no cambian.
• Cuando necesites reasignar valores frecuentemente, opta por let.
• Evita var salvo casos específicos.
• Usa herramientas como ESLint para detectar malas prácticas antes de lanzar tu código al mundo.

El objetivo final: tener un código limpio, entendible… ¡y sin efectos secundarios sorpresa!

Algunos ejemplos prácticos para aclarar dudas

Vamos con ejemplos simples pero ilustrativos:

1. Variables dentro de bucles:

for (var i = 0; i < 3; i  ) {
  // 'i' vive aquí...
}
console.log(i); // Muestra 3 – porque 'i' se quedó global o en toda la función.

vs

for (let j = 0; j < 3; j  ) {
  // 'j' solo existe aquí...
}
console.log(j); // Error – j no definida fuera del ciclo.

2. Modificación interna en objetos constantes:

const persona = { nombre: "Ana" };
persona.nombre = "María"; // Perfecto! Se puede modificar propiedad.

Pero…

persona = { nombre: "Carlos" }; // Error! No puedes re-asignar toda la referencia.

Estas pequeñas diferencias marcan mucho el rumbo cuando escribes código diario.

Si quieres simplificarte las cosas día a día:

• Usa const siempre que puedas.
• Cuando tengas que variar valores dentro del mismo bloque, opta por let.
• Solo recurre a var si tienes alguna necesidad muy específica o trabajas con legado antiguo.

No olvides estos detalles porque te ahorrarán muchas vueltas innecesarias y harán tus programas más robustos y fáciles de entender —tanto para ti como para quien tenga que leer tu código después.