Un worker
El worker es un archivo aparte. Recibe mensajes, trabaja y responde:
// primos.js: corre en otro hilo
self.addEventListener("message", (e) => {
const hasta = e.data;
const primos = [];
for (let n = 2; n <= hasta; n++) {
if (primos.every((p) => n % p !== 0)) primos.push(n);
}
self.postMessage(primos.length);
});
// main.js: en la página
const worker = new Worker(new URL("./primos.js", import.meta.url), { type: "module" });
worker.addEventListener("message", (e) => {
mostrar(`Hay ${e.data} primos`);
});
worker.addEventListener("error", (e) => console.error("falló el worker:", e.message));
worker.postMessage(200_000); // la página sigue respondiendo mientras tanto
Con { type: "module" }, el worker puede usar import. Para detenerlo: worker.terminate() desde la página, o self.close() desde adentro.
Qué puede y qué no
Un worker tiene casi todo el lenguaje y muchas APIs: fetch, temporizadores, IndexedDB, WebSocket, crypto, OffscreenCanvas… Pero no tiene DOM: ni document, ni window, ni acceso a la página. Todo lo que tenga que verse, lo hace la página con los resultados que recibe.
Mensajes: copiar o transferir
Lo que envías con postMessage se copia con la clonación estructurada, la misma de structuredClone: funcionan los objetos, arrays, fechas, Map, Set y arrays tipados, pero no las funciones ni los elementos del DOM.
Copiar datos grandes cuesta. Un ArrayBuffer (y algunos otros objetos) se puede transferir: la memoria pasa al otro hilo sin copiarse, y el original queda vacío.
const imagen = new Uint8Array(10_000_000); // 10 MB
// worker.postMessage(imagen.buffer, [imagen.buffer]) hace esto mismo:
const recibido = structuredClone(imagen.buffer, { transfer: [imagen.buffer] });
console.log(imagen.byteLength); // 0: ya no es de la página
console.log(recibido.byteLength); // 10000000: la memoria pasó entera, sin copiarse
Memoria compartida: SharedArrayBuffer y Atomics
Transferir mueve la memoria de un hilo a otro. A veces los dos hilos necesitan ver la misma memoria a la vez. Un SharedArrayBuffer enviado con postMessage no se copia ni se mueve, así que la página y el worker leen y escriben los mismos bytes. Para no pisarse, se usan las operaciones de Atomics:
// En la página
const memoria = new Int32Array(new SharedArrayBuffer(4));
worker.postMessage(memoria); // el worker ve los mismos bytes
// Esperar un cambio sin congelar la página (ES2024)
const { async, value } = Atomics.waitAsync(memoria, 0, 0);
if (async) value.then(() => mostrar(Atomics.load(memoria, 0)));
// En worker.js
self.onmessage = ({ data: memoria }) => {
Atomics.store(memoria, 0, 42);
Atomics.notify(memoria, 0); // despierta a quien espera
};
Atomics.wait bloquea el hilo, por eso la página no puede usarlo. Atomics.waitAsync hace lo mismo con una promesa. Por seguridad, SharedArrayBuffer solo existe si la página está aislada con las cabeceras Cross-Origin-Opener-Policy: same-origin y Cross-Origin-Embedder-Policy: require-corp. Puedes comprobarlo con crossOriginIsolated. Para la mayoría de los casos, los mensajes alcanzan.
Canales propios
MessageChannel crea un par de puertos conectados: lo que se envía por uno llega por el otro. Sirve para darle a dos partes un canal privado:
const canal = new MessageChannel();
canal.port2.onmessage = (e) => {
console.log("port2 recibió:", e.data);
canal.port2.postMessage(e.data.toUpperCase());
};
canal.port1.onmessage = (e) => console.log("port1 recibió:", e.data);
canal.port1.postMessage("hola");
await new Promise((r) => setTimeout(r, 20));
Entre pestañas: BroadcastChannel
BroadcastChannel reparte mensajes entre todas las pestañas, ventanas y workers del mismo origen que abran un canal con el mismo nombre:
const sesion = new BroadcastChannel("sesion");
sesion.addEventListener("message", (e) => {
if (e.data === "cerrar") mostrarPantallaDeIngreso();
});
botonSalir.addEventListener("click", () => {
sesion.postMessage("cerrar"); // las demás pestañas se enteran
cerrarSesion();
});
Resumen
- Un Web Worker ejecuta código en otro hilo: la página no se congela.
- Los workers no tienen DOM; se comunican con
postMessagey el eventomessage. - Los mensajes se copian (clonación estructurada); los
ArrayBufferse pueden transferir. SharedArrayBuffercomparte memoria entre hilos;Atomics.waitAsync(ES2024) espera un cambio sin congelar la página.MessageChannelcrea un canal privado de dos puertos;BroadcastChannelhabla entre pestañas.- Para pedidos y respuestas, identifica cada pedido con un
id.
¡A practicar!
Tu progreso se guarda en este navegador.
Autoevaluación: Otro hilo para el trabajo pesado
Resuelto
Elige una respuesta en cada pregunta.
¿Para qué sirve un Web Worker?
¿Puede un worker tocar el DOM?
¿Qué pasa con un objeto que envías con
postMessage?¿Para qué sirve
BroadcastChannel?
Ordena la salida: Lo que viaja en un mensaje
Resuelto
Lo que se puede y no se puede enviar en un mensaje. Ordena lo que aparecería en la consola.
1const original = { fecha: new Date(0), lista: new Set([1, 2]), saludar() {} };2 3try {4 structuredClone(original); // lo mismo que hace postMessage5} catch (e) {6 console.log(e.name);7}8 9delete original.saludar;10const copia = structuredClone(original);11console.log(copia.fecha instanceof Date, copia.lista.size);12 13const buffer = new ArrayBuffer(8);14const movido = structuredClone(buffer, { transfer: [buffer] });15console.log(buffer.byteLength, movido.byteLength);Consola, de arriba abajo
- true 2
- 0 8
- DataCloneError
Un mensaje con una función no se puede clonar. Sin ella, las fechas y los conjuntos llegan intactos. Al transferir un buffer, la memoria pasa al destino y el original queda vacío: no hay copia.
Detective: Enviar una función a un worker
Resuelto
Se quería decirle al worker qué operación hacer. Encuentra la línea que falla y elige el arreglo.
Consola
Uncaught DataCloneError: Failed to execute 'postMessage' on 'Worker': (n) => n * 2 could not be cloned.
at app.js:3:8Paso 1: toca la línea de código que causa el error.
Paso 2: ¿cómo lo arreglas?
Laboratorio: Respuestas que llegan desordenadas
Resuelto
Escribe calcular(numero): envía pedidos por mensajes y devuelve, con una promesa, la respuesta que corresponde a cada uno.
La página index.html
Consola del navegador
Lo que debe cumplir
- Imprime
4 25 81, cada resultado con su número (pendiente) - Funciona en llamadas sueltas (pendiente)
- Identifica cada pedido con un
idy escucha las respuestas (pendiente)
Una solución
1const pendientes = new Map();2let siguiente = 0;3 4trabajador.onmessage = (e) => {5 const { id, resultado } = e.data;6 pendientes.get(id)?.(resultado);7 pendientes.delete(id);8};9 10function calcular(numero) {11 return new Promise((resolver) => {12 const id = siguiente++;13 pendientes.set(id, resolver);14 trabajador.postMessage({ id, numero });15 });16}17 18const [a, b, c] = await Promise.all([calcular(2), calcular(5), calcular(9)]);19console.log(a, b, c);Los mensajes no tienen "respuesta" incorporada: es un canal en las dos direcciones. Para saber qué respuesta corresponde a qué pedido, se numera cada uno y se guarda su resolver. Librerías como Comlink hacen exactamente esto por ti.