Saltar al contenido
Cómo se ejecuta JS por dentro

Contextos de ejecución y hoisting

Lección 3 de 712 min4 ejercicios

Antes de ejecutar la primera línea de tu programa, el motor ya hizo un trabajo invisible: recorrió el código y preparó todas las variables y funciones. Ese paso explica comportamientos que parecen magia, como usar una función antes de escribirla, o que una variable valga undefined "porque sí".

Qué mirar en el pizarrón

El paso 1 ocurre antes de la línea 1: es la fase de creación. Fíjate en cómo queda registrada cada declaración. Después mira qué pasa al usar saludo y sumar antes de sus líneas.

En el pizarrón

console.log(saludo);console.log(sumar(2, 3)); var saludo = "hola";let nombre = "Ana"; function sumar(a, b) {  return a + b;} console.log(nombre);

Variables

  1. saludovar · undefined
  2. nombrelet · sin inicializar (zona muerta)
  3. sumarfunction · lista para usar
Consola(vacía)

Antes de ejecutar la línea 1, el motor crea el contexto de ejecución global y recorre el código buscando declaraciones. var saludo se registra con undefined, let nombre se registra sin inicializar y la función sumar queda completa. A esto se le llama hoisting ("elevación").

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

Ver todos los pasos en texto
  1. Paso 1: Antes de ejecutar la línea 1, el motor crea el contexto de ejecución global y recorre el código buscando declaraciones. var saludo se registra con undefined, let nombre se registra sin inicializar y la función sumar queda completa. A esto se le llama hoisting ("elevación"). Variables: saludo var · undefined, nombre let · sin inicializar (zona muerta), sumar function · lista para usar.
  2. Paso 2: saludo ya existe, pero todavía vale undefined: la asignación de la línea 4 no ocurrió. No hay error, y por eso este fallo pasa desapercibido. Variables: saludo var · undefined, nombre let · sin inicializar (zona muerta), sumar function · lista para usar.
  3. Paso 3: Las declaraciones de función se elevan completas: puedes llamar a sumar antes de la línea donde está escrita. Variables: saludo var · undefined, nombre let · sin inicializar (zona muerta), sumar function · lista para usar.
  4. Paso 4: Ahora sí se ejecuta la asignación: saludo pasa a valer "hola". Variables: saludo var · "hola", nombre let · sin inicializar (zona muerta), sumar function · lista para usar.
  5. Paso 5: nombre sale de la zona muerta temporal (TDZ): desde aquí se puede usar. Si la hubieras leído antes de esta línea, el motor habría lanzado ReferenceError: Cannot access 'nombre' before initialization. Variables: saludo var · "hola", nombre let · "Ana", sumar function · lista para usar.
  6. Paso 6: Se imprime Ana. Cada vez que se llama a una función, el motor repite este proceso: crea un contexto nuevo para ella y lo apila en la pila de llamadas. Variables: saludo var · "hola", nombre let · "Ana", sumar function · lista para usar.

El contexto de ejecución

Un contexto de ejecución es el “espacio de trabajo” donde corre un trozo de código. Contiene:

  • Las variables y funciones declaradas ahí.
  • Una referencia a su entorno exterior, para buscar lo que no encuentra dentro. Es la cadena de scopes, el próximo tema.
  • El valor de this, que verás en la sección de Funciones.

Hay un contexto global, creado al empezar el programa, y uno nuevo por cada llamada a función. Esos contextos son los marcos que viste en la pila de llamadas: cada vez que se llama a una función, su contexto se apila; cuando termina, se desapila.

Dos fases: creación y ejecución

Cada contexto pasa por dos fases:

  1. Creación: el motor recorre el código del contexto sin ejecutarlo y registra todas las declaraciones.
  2. Ejecución: recién ahora ejecuta las líneas, una por una.

Lo que se registra en la creación, y cómo, depende del tipo de declaración:

Declaración En la fase de creación queda… Si la usas antes de su línea…
var x = 5 registrada con undefined vale undefined, sin error
let x = 5 / const x = 5 registrada sin inicializar ReferenceError
function f() {} registrada completa, con su cuerpo funciona
const f = function () {} igual que const ReferenceError

A este comportamiento se le llama hoisting (“elevación”), porque es como si las declaraciones subieran al principio. Pero nada se mueve: es la fase de creación la que las registra antes de ejecutar.

La zona muerta temporal

Entre el inicio de su bloque y su propia línea, una variable let o const existe pero está en la zona muerta temporal (TDZ, temporal dead zone). Usarla ahí es un error:

try {
  console.log(color);
  let color = "azul";
} catch (error) {
  console.log(error.message);
}

Parece un fastidio, pero es una protección: con var el mismo código imprimiría undefined y el fallo pasaría desapercibido.

Funciones antes de declararlas

Las declaraciones de función quedan completas en la fase de creación, así que puedes llamarlas antes de su línea. Eso permite escribir primero el programa principal y abajo los detalles:

console.log(areaCirculo(2));

function areaCirculo(radio) {
  return Math.PI * radio ** 2;
}

Las expresiones de función guardadas en una constante no tienen ese privilegio: siguen las reglas de const.

try {
  console.log(saludar("Ana"));
} catch (error) {
  console.log(error.message);
}

const saludar = function (nombre) {
  return `Hola, ${nombre}`;
};

Resumen

  • Un contexto de ejecución guarda las variables de un trozo de código y su enlace al exterior. Hay uno global y uno por cada llamada a función.
  • Cada contexto tiene una fase de creación, que registra declaraciones, y una de ejecución.
  • var se registra con undefined; let y const quedan en la zona muerta temporal hasta su línea.
  • Las declaraciones de función se elevan completas; las funciones en constantes, no.
  • Declara antes de usar: el código se lee mejor y el motor te protege.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Qué se eleva y cómo

Elige una respuesta en cada pregunta.

  1. ¿Qué imprime?
    console.log(x);
    var x = 5;

  2. ¿Y con let?
    console.log(y);
    let y = 5;

  3. ¿Se puede llamar a una función antes de la línea donde está declarada con function nombre() { … }?

  4. ¿Cuándo crea el motor un nuevo contexto de ejecución?

Ordena la salida: Antes y después de declarar

Piensa en la fase de creación antes de ordenar lo que aparecería en la consola.

console.log(tipo);console.log(doble(4)); var tipo = "var"; function doble(n) {  return n * 2;} console.log(tipo);

Consola, de arriba abajo

  1. var
  2. undefined
  3. 8

Detective: Una constante usada antes de tiempo

El error salta dentro de la función, pero la causa está en otro lado. Encuentra la línea que provoca el problema y elige el arreglo.

Consola

tienda.js:6
  return 100 * (1 + IVA);
                    ^

ReferenceError: Cannot access 'IVA' before initialization

Paso 1: toca la línea de código que causa el error.

Laboratorio: Declara antes de usar

Este código lanza un error de zona muerta temporal. Arréglalo sin usar var, para que imprima Hola, Ana.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime Hola, Ana (pendiente)
  • Sigue usando const y let (sin var) (pendiente)
  • Las declaraciones van antes del console.log (pendiente)

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