Qué es el ámbito
Cada variable vive en una zona del código: su ámbito (scope). Fuera de esa zona, la variable no existe. Esto no es una limitación molesta, sino una protección: evita que partes lejanas del programa pisen las variables de otras.
Ámbito global
Una variable declarada fuera de toda función o bloque es global: se puede usar en cualquier parte del archivo.
const app = "Mi tienda";
function titulo() {
return "Bienvenido a " + app;
}
console.log(titulo()); // Bienvenido a Mi tienda
Ámbito de función
Las variables declaradas dentro de una función solo existen dentro de ella:
function calcular() {
const secreto = 42;
return secreto * 2;
}
console.log(calcular()); // 84
console.log(secreto); // ReferenceError: secreto is not defined
Los parámetros también son locales a su función.
Ámbito de bloque
Un bloque es cualquier código entre llaves { }: el cuerpo de un if, de un for o simplemente un par de llaves sueltas. let y const respetan los bloques:
const edad = 20;
if (edad >= 18) {
const mensaje = "Mayor de edad";
console.log(mensaje); // Mayor de edad
}
console.log(mensaje); // ReferenceError: mensaje is not defined
Por eso en un for (let i = 0; ...) la variable i no existe fuera del bucle.
Se ve hacia afuera, no hacia adentro
Cuando usas una variable, JavaScript la busca primero en el ámbito actual. Si no la encuentra, sube al ámbito que lo contiene, y así hasta el global. Nunca baja a ámbitos internos.
const a = "global";
function externa() {
const b = "de externa";
function interna() {
const c = "de interna";
console.log(a, b, c); // ve las tres
}
interna();
// aquí no se ve c
}
externa(); // global de externa de interna
Shadowing
Si declaras una variable interna con el mismo nombre que una externa, la interna oculta a la externa dentro de su ámbito:
const color = "azul";
function pintar() {
const color = "rojo";
return color;
}
console.log(pintar()); // rojo
console.log(color); // azul
Es válido, pero puede confundir. Usa nombres distintos cuando signifiquen cosas distintas.
Closures
Aquí viene una idea poderosa. Una función recuerda las variables del ámbito donde se creó, aunque se ejecute después y en otro lugar. A esa combinación de función más variables recordadas se le llama closure (clausura).
function crearContador() {
let cuenta = 0;
return () => {
cuenta++;
return cuenta;
};
}
const contar = crearContador();
console.log(contar()); // 1
console.log(contar()); // 2
console.log(contar()); // 3
crearContador ya terminó de ejecutarse, pero la función flecha que devolvió sigue teniendo acceso a cuenta. Además, nadie más puede tocar esa variable: solo la función devuelta. Es una forma de tener datos privados.
Cada llamada a crearContador crea un ámbito nuevo, con su propia cuenta:
const a = crearContador();
const b = crearContador();
a(); a();
console.log(a()); // 3
console.log(b()); // 1