CKTIS / JavaScript
Worker: `message`, `error` und `messageerror` behandeln
Unterscheide drei Ereignisse eines dedizierten Workers: eine zugestellte Nachricht, einen Worker-Fehler und eine Nachricht, die der Empfänger nicht deserialisieren kann.
Version: ECMAScript 2024 and the current web platform; runtime support varies
Syntax
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 und worker.onmessageerror sind Ereignishandler-Eigenschaften der dedizierten Worker-Instanz auf der Seite, die sie erstellt hat. Sie sind in HTML definiert, nicht in ECMAScript 2024. Die Unterstützung hängt von der Laufzeitumgebung ab, besonders bei messageerror. Richte die Handler vor der ersten Anfrage ein.
onmessage erhält ein MessageEvent, wenn eine Nachricht des Workers erfolgreich deserialisiert wurde. Lies die Nutzdaten aus event.data und prüfe, ob sie die erwartete Struktur haben: Das strukturierte Klonen validiert dein Anwendungsprotokoll nicht. Im Worker verarbeitet self.onmessage die Gegenrichtung, also Nachrichten von der Seite, die ihn erstellt hat.
onerror erhält ein einzelnes Ereignisobjekt. Eine nicht abgefangene synchrone Ausnahme, die an die Erstellerseite gemeldet wird, erzeugt ein ErrorEvent; verlasse dich nicht darauf, dass event.error die ursprüngliche Ausnahme enthält. Scheitert das Laden des Skripts, kann ein einfaches Event eintreffen. Bei einem abbrechbaren Ereignis kann event.preventDefault() die weitere Meldung unterbinden, setzt den unterbrochenen Code aber nicht fort. Im Worker hat self.onerror für ErrorEvent aus historischen Gründen fünf Argumente und kann die Meldung mit return true unterbinden. Für worker.onerror gilt diese Regel nicht.
onmessageerror erhält statt message ein nicht abbrechbares MessageEvent, wenn die Empfängerseite eine Nachricht nicht deserialisieren kann. Es gibt dann keine dekodierten Nutzdaten. Übergibt der Sender dagegen eine Funktion an postMessage(), löst der Aufruf dort synchron DataCloneError aus. Auf der Empfängerseite entsteht kein messageerror.
Jede Eigenschaft enthält einen Handler: Eine neue Zuweisung ersetzt ihn, null entfernt ihn. Mit addEventListener() und dem Ereignisnamen ohne on lassen sich unabhängige Listener registrieren. Rufe worker.terminate() auf, wenn du den Worker nicht mehr brauchst. Die Methode wartet nicht auf ausstehende Arbeit.
Beispiele
(() => {
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);
})();Ergebnis
send: DataCloneError message: 42 messageerror (synthetic) error: runtime
Um die Ereignishandler-Eigenschaften von Web Workern auszuprobieren, führe das vollständige Beispiel in der Browserkonsole einer Seite aus, deren Sicherheitsrichtlinie `blob:`-Worker erlaubt. Speichere es für Node.js 24 als `main.cjs` und führe `node main.cjs` aus. Dieser Zweig verwendet `node:worker_threads` statt der Handler-Eigenschaften von `Worker` im Browser. In beiden Umgebungen prüft `messageerror (synthetic)` nur den Handler, keinen echten Deserialisierungsfehler und keine native Ereignisunterstützung.
Zugehörige Lektionen
- JavaScript · Lektion 32 · Fortgeschritten · Version: 4
Quellen
- 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