Saltar al contenido

Sección 2: Control de flujo, 0 de 4 lecciones completadas

Lección 08 de 22Control de flujo

Ámbito y closures

  • 6 min de lectura
  • 2 ejercicios

Entiende el ámbito en JavaScript: qué variables se ven desde cada parte del código, el ámbito de bloque de let y const y cómo funcionan los closures.

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

Puntos clave

  • El ámbito (scope) define desde dónde se puede usar una variable.
  • let y const tienen ámbito de bloque: solo existen dentro de las llaves donde se declaran.
  • Desde dentro se ve hacia afuera, pero no al revés.
  • Una variable interna con el mismo nombre que una externa la oculta (shadowing).
  • Un closure es una función que recuerda las variables del lugar donde se creó.

Hora de practicar

Ejercicios

0/2 resueltos

Reto 1 de 2

Ejercicio 1: Arregla el ámbito

Este código lanza ReferenceError: total is not defined, porque total se declara dentro del bucle y se usa fuera. Muévelo para que la salida sea:

15
const numeros = [1, 2, 3, 4, 5];

for (const n of numeros) {
  // TODO: total no debería declararse aquí dentro
  let total = 0;
  total += n;
}

console.log(total);

Pulsa «Ejecutar» (o Ctrl + Enter) para ver la salida.

Reto 2 de 2

Ejercicio 2: Fábrica de multiplicadores

Completa crearMultiplicador(factor) para que devuelva una función que reciba un número y lo multiplique por factor. Es un closure: la función devuelta recuerda factor.

const triple = crearMultiplicador(3);
triple(5); // 15
function crearMultiplicador(factor) {
  // TODO: devuelve una función que reciba n y devuelva n * factor
}

Pulsa «Ejecutar» (o Ctrl + Enter) para ver la salida.

Has llegado al final de «Control de flujo». Haz el examen de la sección.

¿Has encontrado un error en esta lección? Avísanos