Saltar al contenido
Módulos

ES Modules

Lección 1 de 411 min3 ejercicios

Un programa real no cabe en un archivo. Los módulos permiten dividirlo en piezas, cada una con su propio scope, que deciden qué muestran hacia afuera (export) y qué necesitan de las demás (import). Es el sistema estándar de JavaScript, el mismo en el navegador, Node.js, Deno y Bun.

export e import

Un módulo es un archivo. Lo que no se exporta es privado:

// matematicas.js
const PI_APROX = 3.14;                     // privado: nadie más lo ve

export function areaCirculo(r) {           // exportación con nombre
  return PI_APROX * r * r;
}

export const nombre = "matemáticas";

export default function sumar(a, b) {      // exportación por defecto (una por módulo)
  return a + b;
}
// main.js
import sumar, { areaCirculo, nombre as modulo } from "./matematicas.js";
import * as mat from "./matematicas.js";   // todo, como un objeto

console.log(sumar(2, 3));
console.log(areaCirculo(2), modulo);
console.log(mat.nombre);
  • Las exportaciones con nombre se importan entre llaves, con el mismo nombre (o renombradas con as).
  • La exportación por defecto se importa sin llaves, con el nombre que elijas.
  • Muchos equipos prefieren usar solo exportaciones con nombre: el nombre es el mismo en todo el proyecto y los editores lo autocompletan mejor.

Cómo se carga un módulo

  1. Se leen todos los import antes de ejecutar nada: por eso solo pueden ir en el nivel superior.
  2. Se cargan las dependencias, y las dependencias de las dependencias.
  3. Se evalúan de las hojas a la raíz: un módulo corre después de todo lo que importa.
  4. Cada módulo se evalúa una sola vez, aunque lo importen cien archivos.

Además, todo módulo corre en modo estricto, tiene su propio scope (sus variables no son globales) y su this en el nivel superior es undefined.

Enlaces vivos

Lo que importas no es una copia, sino un enlace a la variable del otro módulo. Si el módulo la cambia, lo ves:

// contador.js
export let cuenta = 0;
export function sumar() { cuenta++; }

// main.js
import { cuenta, sumar } from "./contador.js";
sumar();
console.log(cuenta);  // 1: es la misma variable
// cuenta = 5;        // TypeError: los imports son de solo lectura

import() dinámico

import(ruta) carga un módulo cuando hace falta y devuelve una promesa. Sirve para no cargar al principio código pesado que quizá nunca se use:

botonGrafico.addEventListener("click", async () => {
  const { dibujarGrafico } = await import("./grafico-pesado.js");
  dibujarGrafico(datos);
});

La ruta puede calcularse en el momento, por ejemplo con el idioma del usuario:

const textos = await import(`./idiomas/${idioma}.js`);

import.meta

import.meta tiene información sobre el módulo actual:

console.log(import.meta.url);        // la URL de este archivo
console.log(import.meta.resolve("./datos.json")); // la URL de otro, relativa a este
// En Node.js, además:
console.log(import.meta.dirname, import.meta.filename);

Resumen

  • export muestra lo que el módulo ofrece; lo demás es privado.
  • Exportaciones con nombre ({ x }) y por defecto (una por módulo).
  • Los import se resuelven antes de ejecutar; las dependencias se evalúan primero, una sola vez.
  • Los imports son enlaces vivos y de solo lectura.
  • import() carga módulos bajo demanda y devuelve una promesa; import.meta describe el módulo actual.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: import y export

Elige una respuesta en cada pregunta.

  1. ¿Qué diferencia hay entre export const x y export default x?

  2. Si dos archivos importan el mismo módulo, ¿cuántas veces se ejecuta su código?

  3. ¿Qué devuelve import("./grafico.js")?

  4. El código de un módulo, ¿corre en modo estricto?

Ordena la salida: Quién se evalúa primero

Tres archivos que se importan en cadena. Al ejecutar node main.js, ¿en qué orden aparecería cada línea?

// main.jsimport { saludo } from "./a.js";console.log("main:", saludo); // a.jsimport "./b.js";console.log("evaluando a");export const saludo = "hola"; // b.jsconsole.log("evaluando b");

Consola, de arriba abajo

  1. main: hola
  2. evaluando b
  3. evaluando a

Detective: Un import en un script clásico

El navegador se niega a ejecutar el archivo. Encuentra la línea culpable y elige el arreglo.

Consola

Uncaught SyntaxError: Cannot use import statement outside a module (at app.js:1:1)

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

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