Saltar al contenido
Cómo se ejecuta JS por dentro

La pila de llamadas

Lección 2 de 712 min4 ejercicios

JavaScript ejecuta tu código en un solo hilo: hace una cosa a la vez, en orden. Para no perderse cuando una función llama a otra, el motor lleva una lista de pendientes llamada pila de llamadas (call stack). La última función que entra es la primera que sale, como una pila de platos.

Qué mirar en el pizarrón

Pulsa Siguiente y sigue dos cosas a la vez: la línea subrayada en amarillo es la que se ejecuta, y la columna Pila muestra qué funciones están esperando su turno. En algunos pasos el pizarrón te pedirá que predigas qué viene.

En el pizarrón

function saludar(nombre) {  return `Hola, ${nombre}!`;} function mostrar() {  const msg = saludar("Mundo");  console.log(msg);} mostrar();

Pilacima

  1. mostrar()
Consola(vacía)

mostrar() entra a la pila. El motor empieza a ejecutar su cuerpo desde la línea 5.

Con el foco aquí también puedes avanzar y retroceder con las flechas del teclado.

Ver todos los pasos en texto
  1. Paso 1: mostrar() entra a la pila. El motor empieza a ejecutar su cuerpo desde la línea 5. Pila: mostrar().
  2. Paso 2: Dentro de mostrar(), el motor llega a la línea 6 y encuentra una llamada: saludar("Mundo"). Pila: mostrar().
  3. Paso 3: saludar() se apila encima de mostrar(). El motor suspende mostrar() y ejecuta saludar(). Pila: mostrar() → saludar().
  4. Paso 4: saludar() arma el texto "Hola, Mundo!" y lo devuelve con return. Pila: mostrar() → saludar().
  5. Paso 5: saludar() terminó y sale de la pila. El motor vuelve a la línea 6 de mostrar() y guarda el resultado en msg. Pila: mostrar().
  6. Paso 6: console.log(msg) también es una función, así que entra a la pila encima de mostrar(). Pila: mostrar() → console.log().
  7. Paso 7: console.log() escribe Hola, Mundo! en la consola y sale de la pila. Pila: mostrar().
  8. Paso 8: mostrar() llega a su llave de cierre y sale. La pila queda vacía: el programa terminó. Pila: vacía.

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:

  1. mostrar() entra a la pila porque el código principal la llama.
  2. Al llegar a saludar("Mundo"), se apila saludar() y mostrar() queda esperando en la línea 6.
  3. saludar() hace return y sale. mostrar() vuelve a la cima y continúa justo donde estaba, ya con el valor en msg.
  4. console.log() también es una función: entra, imprime y sale.
  5. 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

function cuenta(n) {  console.log(n);  cuenta(n + 1);} cuenta(1);

Pilacima

  1. cuenta(1)n = 1
Consola(vacía)

cuenta(1) entra a la pila.

Con el foco aquí también puedes avanzar y retroceder con las flechas del teclado.

Ver todos los pasos en texto
  1. Paso 1: cuenta(1) entra a la pila. Pila: cuenta(1).
  2. Paso 2: Imprime 1. Pila: cuenta(1).
  3. 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).
  4. Paso 4: cuenta(2) imprime 2… Pila: cuenta(1) → cuenta(2).
  5. 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).
  6. 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).
  7. 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 return o 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

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().

function c() {  console.log("¡Hola desde c!");} function b() {  c();} function a() {  b();} a();

Tu pilacima

    Movimiento 1 de 6

    Ordena la salida: ¿En qué orden aparece cada letra?

    Ordena las líneas tal como aparecerían en la consola. Puedes arrastrarlas o usar las flechas.

    function primero() {  console.log("A");  segundo();  console.log("D");} function segundo() {  console.log("B");  console.log("C");} primero();console.log("E");

    Consola, de arriba abajo

    1. D
    2. A
    3. E
    4. C
    5. B

    Detective: El factorial que nunca termina

    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.

    Laboratorio: Escribe una cuenta atrás recursiva

    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.

    programa.jsse ejecuta mientras escribes

    $ node programa.js

    (escribe tu código: se ejecuta solo)

    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 for ni while (pendiente)

      domina-js · JavaScript en español, gratis y paso a paso.