Un solo hilo
Un hilo es una línea de trabajo: una secuencia de instrucciones que se ejecutan una detrás de otra. JavaScript tiene uno solo para tu código. Mientras ejecuta una línea, no puede estar ejecutando otra al mismo tiempo.
Eso lo hace predecible: si lees el código de arriba hacia abajo, sabes en qué orden va a pasar todo. Pero aparece un problema en cuanto una función llama a otra. Si mostrar() llama a saludar(), el motor tiene que dejar mostrar() a medias, ejecutar saludar() completa y después volver exactamente a donde estaba. Para recordar a dónde volver, usa la pila.
Qué es una pila
Una pila es una estructura en la que solo se puede tocar lo que está arriba:
- Apilar (push): poner algo encima.
- Desapilar (pop): sacar lo que está encima.
Como en una pila de platos, el último que pusiste es el primero que sacas. A esto se le llama LIFO, de last in, first out: último en entrar, primero en salir.
En la pila de llamadas, cada plato es un marco (stack frame): una función que está en ejecución, con sus variables y la línea en la que va. Cada vez que llamas a una función, se apila un marco nuevo. Cada vez que una función termina (con return o al llegar a su }), su marco se desapila y el motor sigue con el de abajo.
Lo que pasó en el pizarrón
Si recorriste los 8 pasos de arriba, viste el ciclo completo:
mostrar()entra a la pila porque el código principal la llama.- Al llegar a
saludar("Mundo"), se apilasaludar()ymostrar()queda esperando en la línea 6. saludar()hacereturny sale.mostrar()vuelve a la cima y continúa justo donde estaba, ya con el valor enmsg.console.log()también es una función: entra, imprime y sale.mostrar()termina y la pila queda vacía.
Puedes ver esta misma pila en tu navegador. Abre las DevTools (F12), pestaña Sources, pon un breakpoint dentro de saludar() y mira el panel Call Stack: aparecen saludar arriba y mostrar debajo, igual que en el pizarrón.
Cuando la pila se desborda
La pila no es infinita. Si una función se llama a sí misma sin una condición que la detenga, cada llamada apila un marco nuevo y ninguno sale nunca. Mira qué pasa con esta función, y fíjate en la gráfica de profundidad: la pila solo sube.
Una pila que no para
1function cuenta(n) {2 console.log(n);3 cuenta(n + 1);4}5 6cuenta(1);Pilacima
- cuenta(1)n = 1
La pila está vacía.
cuenta(1) entra a la pila.
Predice
Con el foco aquí también puedes avanzar y retroceder con las flechas del teclado.
Ver todos los pasos en texto
- Paso 1: cuenta(1) entra a la pila. Pila: cuenta(1).
- Paso 2: Imprime 1. Pila: cuenta(1).
- Paso 3: En la línea 3 se llama a sí misma: cuenta(2) se apila encima. cuenta(1) no terminó, queda esperando. Pila: cuenta(1) → cuenta(2).
- Paso 4: cuenta(2) imprime 2… Pila: cuenta(1) → cuenta(2).
- Paso 5: …y llama a cuenta(3), que imprime 3. Ninguna función termina: la pila solo crece. Pila: cuenta(1) → cuenta(2) → cuenta(3).
- Paso 6: Así miles de veces. La pila tiene un tamaño máximo; el número exacto depende del motor y del navegador. Pila: cuenta(1) → cuenta(2) → cuenta(3) → ⋮ → cuenta(10 000).
- Paso 7: La pila se llenó: el motor lanza RangeError: Maximum call stack size exceeded y descarta todos los marcos. Eso es un stack overflow. Pila: vacía.
Una función que se llama a sí misma se llama recursiva, y no tiene nada de malo. Lo que falló aquí es que no tiene un caso base: una condición en la que la función termina sin volver a llamarse.
function cuenta(n) {
if (n > 3) return; // caso base: aquí se corta
console.log(n);
cuenta(n + 1);
}
cuenta(1); // imprime 1, 2, 3 y la pila se vacía
Si es de un solo hilo, ¿cómo espera?
Si JavaScript hace una cosa a la vez, ¿qué pasa con setTimeout(fn, 1000)? ¿Se queda el motor un segundo sin hacer nada, con la función en la pila?
No. setTimeout entra a la pila, le pide al navegador que lleve la cuenta del tiempo y sale enseguida. La función fn no está en la pila mientras espera. Cuando pasa el segundo, la pone en una cola, y solo entra a la pila cuando esta queda vacía. Quien mueve las cosas de la cola a la pila es el event loop, el tema de la sección de Asincronía.
Resumen
- JavaScript ejecuta tu código en un solo hilo: una cosa a la vez.
- La pila de llamadas registra qué funciones están en ejecución. La de la cima es la que corre ahora.
- Llamar a una función la apila. Terminar (con
returno al llegar a su}) la desapila. - Es LIFO: la última en entrar es la primera en salir.
- Una recursión sin caso base llena la pila y produce un stack overflow.
¡A practicar!
Tu progreso se guarda en este navegador.
Sé el motor: Apila y desapila como lo haría el motor
Resuelto
Tú eres el motor. Sigue el código desde la última línea y usa los botones para apilar y desapilar cada función en el orden correcto. No hace falta apilar console.log().
1function c() {2 console.log("¡Hola desde c!");3}4 5function b() {6 c();7}8 9function a() {10 b();11}12 13a();Tu pilacima
Movimiento 1 de 6
Ordena la salida: ¿En qué orden aparece cada letra?
Resuelto
Ordena las líneas tal como aparecerían en la consola. Puedes arrastrarlas o usar las flechas.
1function primero() {2 console.log("A");3 segundo();4 console.log("D");5}6 7function segundo() {8 console.log("B");9 console.log("C");10}11 12primero();13console.log("E");Consola, de arriba abajo
- D
- A
- E
- C
- B
primero() imprime A y llama a segundo(), que se apila encima e imprime B y C. Cuando segundo() sale, primero() sigue donde se quedó e imprime D. Al final, con la pila vacía, se imprime E.
Detective: El factorial que nunca termina
Resuelto
Alguien quiso calcular factorial(5) y la consola mostró este error. Encuentra la línea culpable y elige el arreglo.
Consola
Uncaught RangeError: Maximum call stack size exceeded
at factorial (factorial.js:2:14)
at factorial (factorial.js:2:14)
at factorial (factorial.js:2:14)
at factorial (factorial.js:2:14)
…Paso 1: toca la línea de código que causa el error.
Paso 2: ¿cómo lo arreglas?
Laboratorio: Escribe una cuenta atrás recursiva
Resuelto
Completa cuentaAtras(n) para que imprima los números desde n hasta 1 y luego ¡Despegue!, usando recursión. Las verificaciones se ponen en verde mientras escribes.
$ node programa.js
Lo que debe cumplir
cuentaAtras(3)imprime 3, 2, 1 y después¡Despegue!(pendiente)- Funciona con otro número:
cuentaAtras(5)(pendiente) cuentaAtras(0)solo imprime¡Despegue!: ese es el caso base (pendiente)- Se llama a sí misma, sin
forniwhile(pendiente)
Una solución
1function cuentaAtras(n) {2 if (n === 0) {3 console.log("¡Despegue!");4 return;5 }6 console.log(n);7 cuentaAtras(n - 1);8}9 10cuentaAtras(3);Con cuentaAtras(3) la pila crece hasta tener cuatro marcos: cuentaAtras(3), (2), (1) y (0). El caso base n === 0 es el que corta: imprime y hace return sin volver a llamarse. Desde ahí la pila se vacía de arriba hacia abajo.