CKTIS / JavaScript
Worker: cómo gestionar `message`, `error` y `messageerror`
Distingue tres eventos de un worker dedicado: un mensaje recibido, un error del worker y un mensaje que el receptor no puede deserializar.
Versión: ECMAScript 2024 and the current web platform; runtime support varies
Sintaxis
const worker = new Worker(url);
worker.onmessage = (event) => { /* use event.data */ };
worker.onerror = (event) => { /* handle a worker error */ };
worker.onmessageerror = (event) => { /* handle a receive-side deserialization failure */ };
// Alternative for any of the three properties:
worker.addEventListener("message", handleMessage);
worker.addEventListener("error", handleError);
worker.addEventListener("messageerror", handleMessageError);worker.onmessage, worker.onerror y worker.onmessageerror son propiedades de manejo de eventos de la instancia de Worker dedicado, del lado que la creó. Las define el estándar HTML, no ECMAScript 2024. La compatibilidad depende del entorno de ejecución, especialmente para messageerror. Configura los manejadores antes de enviar la primera solicitud.
onmessage recibe un MessageEvent cuando se deserializa correctamente un mensaje del worker. Lee el contenido en event.data y comprueba que tenga la estructura que espera tu aplicación: la clonación estructurada no valida tu protocolo. Dentro del worker, self.onmessage maneja la dirección contraria, es decir, los mensajes del contexto que lo creó.
onerror recibe un único objeto de evento. Una excepción síncrona no capturada que se notifica al contexto creador produce un ErrorEvent; no des por hecho que event.error contiene la excepción original. Si falla la carga del script, puede recibirse un Event genérico. En un evento cancelable, event.preventDefault() puede impedir que se siga notificando el error, pero no reanuda el código interrumpido. Dentro del worker, self.onerror tiene una forma histórica de cinco argumentos para ErrorEvent y puede cancelar la notificación con return true; esta regla no se aplica a worker.onerror.
onmessageerror recibe un MessageEvent no cancelable en lugar de message cuando el receptor no puede deserializar un mensaje. No hay contenido decodificado que leer. En cambio, pasar una función a postMessage() lanza DataCloneError de forma síncrona del lado emisor y no genera messageerror del lado receptor.
Cada propiedad admite un solo manejador: asignar otro lo sustituye y asignar null lo elimina. Usa addEventListener() con el nombre del evento sin on para registrar escuchas independientes. Llama a worker.terminate() cuando ya no necesites el worker; no espera a que termine el trabajo pendiente.
Ejemplos
(() => {
const inNode = typeof require === "function" &&
typeof process !== "undefined" && Boolean(process.versions?.node);
const handler = `
function handleMessage(data, reply) {
if (data === "fail") throw new Error("demo failure");
reply(data * 2);
}
`;
let worker;
let messageErrorTarget;
function reportMessageError(event) {
console.log(event.isTrusted ? "messageerror" : "messageerror (synthetic)");
}
function receiveReply(data) {
console.log(`message: ${data}`);
messageErrorTarget.dispatchEvent(new MessageEvent("messageerror"));
worker.postMessage("fail");
}
if (inNode) {
const { Worker: ThreadWorker } = require("node:worker_threads");
worker = new ThreadWorker(handler + `
const { parentPort } = require("node:worker_threads");
parentPort.on("message", (data) => {
handleMessage(data, (value) => parentPort.postMessage(value));
});
`, { eval: true });
// Node worker threads do not use the browser's handler properties.
messageErrorTarget = new EventTarget();
messageErrorTarget.addEventListener("messageerror", reportMessageError);
worker.on("message", receiveReply);
worker.on("error", (error) => {
if (error.message !== "demo failure") throw error;
console.log("error: runtime");
});
} else {
const script = handler + `
self.onmessage = ({ data }) => {
handleMessage(data, (value) => self.postMessage(value));
};
`;
const url = URL.createObjectURL(new Blob([script], { type: "text/javascript" }));
try {
worker = new Worker(url);
} catch (error) {
URL.revokeObjectURL(url);
throw error;
}
messageErrorTarget = worker;
worker.onmessage = (event) => receiveReply(event.data);
worker.onmessageerror = reportMessageError;
worker.onerror = (event) => {
event.preventDefault();
console.log(event instanceof ErrorEvent ? "error: runtime" : "error: startup");
worker.terminate();
URL.revokeObjectURL(url);
};
}
try {
worker.postMessage(() => {});
} catch (error) {
console.log(`send: ${error.name}`);
}
worker.postMessage(21);
})();Resultado
send: DataCloneError message: 42 messageerror (synthetic) error: runtime
Para probar las propiedades de manejo de eventos de Web Workers, ejecuta el ejemplo completo en la consola del navegador, en una página cuya política de seguridad permita workers `blob:`. En Node.js 24, guarda el código como `main.cjs` y ejecuta `node main.cjs`; esa rama usa `node:worker_threads`, no las propiedades de manejo de eventos del `Worker` del navegador. En ambos entornos, `messageerror (synthetic)` solo prueba el manejador, no un fallo real de deserialización ni la compatibilidad nativa con el evento.
Lecciones relacionadas
- JavaScript · Lección 32 · Avanzado · Versión: 4
Fuentes
- HTML Standard — Dedicated workers and the Worker interface
- HTML Standard — The worker's lifetime
- HTML Standard — Runtime script errors
- HTML Standard — Event handlers
- HTML Standard — Message ports
- HTML Standard — StructuredSerializeInternal
- Worker: message event
- Worker: messageerror event
- Worker: Worker() constructor
- HTML Standard — Processing model