KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / JavaScript

Worker: `message`, `error` en `messageerror` afhandelen

Onderscheid drie gebeurtenissen van een dedicated worker: een ontvangen bericht, een workerfout en een bericht dat de ontvanger niet kan deserialiseren.

Versie: 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 en worker.onmessageerror zijn eigenschappen voor eventhandlers op de dedicated Worker-instantie, aan de kant die deze instantie heeft aangemaakt. Ze zijn gedefinieerd in HTML, niet in ECMAScript 2024. Ondersteuning hangt af van de uitvoeromgeving, vooral voor messageerror. Stel de handlers in voordat je het eerste verzoek verstuurt.

onmessage krijgt een MessageEvent zodra een bericht van de worker met succes is gedeserialiseerd. Lees de inhoud uit event.data en controleer of die de structuur heeft die je applicatie verwacht: structured cloning controleert je protocol niet. Binnen de worker handelt self.onmessage de omgekeerde richting af, dus berichten vanuit de context die de worker heeft aangemaakt.

onerror krijgt één eventobject. Een niet-afgevangen synchrone uitzondering die aan de aanmakende context wordt gemeld, levert een ErrorEvent op; ga er niet van uit dat event.error de oorspronkelijke uitzondering bevat. Als het laden van het script mislukt, kan een gewoon Event volgen. Bij een annuleerbare gebeurtenis kan event.preventDefault() verdere foutrapportage tegenhouden, maar de onderbroken code wordt niet hervat. Binnen de worker heeft self.onerror voor ErrorEvent een historische vorm met vijf argumenten en kan het verdere rapportage met return true tegenhouden; deze regel geldt niet voor worker.onerror.

onmessageerror krijgt een niet-annuleerbaar MessageEvent in plaats van message als de ontvanger een bericht niet kan deserialiseren. Er is dan geen gedecodeerde inhoud om te lezen. Geef je daarentegen een functie door aan postMessage(), dan werpt die aanroep aan de zendkant synchroon DataCloneError op. Aan de ontvangende kant volgt geen messageerror.

Elke eigenschap bevat één handler: een nieuwe toewijzing vervangt hem en null verwijdert hem. Gebruik addEventListener() met de naam van de gebeurtenis zonder on om onafhankelijke listeners te registreren. Roep worker.terminate() aan als je de worker niet meer nodig hebt; de methode wacht niet totdat openstaand werk klaar is.

Voorbeelden

(() => {
  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);
})();

Resultaat

send: DataCloneError
message: 42
messageerror (synthetic)
error: runtime

Om de eventhandler-eigenschappen van Web Workers uit te proberen, voer je het volledige voorbeeld uit in de browserconsole op een pagina waarvan het beveiligingsbeleid `blob:`-workers toestaat. Sla het voorbeeld voor Node.js 24 op als `main.cjs` en voer `node main.cjs` uit. Die tak gebruikt `node:worker_threads`, niet de eventhandler-eigenschappen van `Worker` in de browser. In beide omgevingen test `messageerror (synthetic)` alleen de handler, niet een echte deserialisatiefout of ingebouwde ondersteuning van de gebeurtenis.

Gerelateerde lessen

  • JavaScript · Les 32 · Gevorderd · Versie: 4

Bronnen