Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / JavaScript

Worker: obsluha událostí `message`, `error` a `messageerror`

Rozliš tři události vyhrazeného workeru: přijetí zprávy, chybu workeru a zprávu, kterou příjemce nedokáže deserializovat.

Verze: ECMAScript 2024 and the current web platform; runtime support varies

Syntaxe

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 a worker.onmessageerror jsou vlastnosti pro obsluhu událostí na instanci vyhrazeného Worker na straně, která ji vytvořila. Definuje je standard HTML, nikoli ECMAScript 2024. Podpora závisí na běhovém prostředí, zejména u messageerror. Obsluhy nastav před odesláním prvního požadavku.

onmessage dostane MessageEvent, když se podaří deserializovat zprávu od workeru. Přečti obsah z event.data a ověř, že má strukturu očekávanou aplikací: strukturované klonování nekontroluje tvůj protokol. Uvnitř workeru obsluhuje self.onmessage opačný směr, tedy zprávy z kontextu, který worker vytvořil.

onerror dostane jeden objekt události. Nezachycená synchronní výjimka oznámená kontextu, který worker vytvořil, vyvolá ErrorEvent; nespoléhej na to, že event.error obsahuje původní výjimku. Selhání načtení skriptu může vyvolat obyčejný Event. U zrušitelné události lze pomocí event.preventDefault() zastavit další hlášení, ale přerušený kód se tím znovu nespustí. Uvnitř workeru má self.onerror pro ErrorEvent historickou podobu s pěti argumenty a může hlášení zastavit pomocí return true; pro worker.onerror toto pravidlo neplatí.

onmessageerror dostane nezrušitelný MessageEvent místo události message, když příjemce nedokáže zprávu deserializovat. Žádný dekódovaný obsah není k dispozici. Předání funkce do postMessage() naproti tomu vyvolá synchronní DataCloneError na straně odesílatele a nezpůsobí messageerror u příjemce.

Každá vlastnost uchovává jednu obsluhu: nové přiřazení ji nahradí a null ji odebere. Nezávislé posluchače přidáš pomocí addEventListener() s názvem události bez on. Až worker nebudeš potřebovat, zavolej worker.terminate(); metoda nečeká na dokončení rozpracovaných ani čekajících úloh.

Příklady

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

Výsledek

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

Chceš-li si vyzkoušet vlastnosti pro obsluhu událostí Web Workeru, spusť celý příklad v konzoli prohlížeče na stránce, jejíž bezpečnostní pravidla povolují workery s adresou `blob:`. Pro Node.js 24 ulož kód jako `main.cjs` a spusť `node main.cjs`; tato větev používá `node:worker_threads`, nikoli vlastnosti pro obsluhu událostí prohlížečového `Worker`. V obou prostředích `messageerror (synthetic)` testuje pouze obsluhu, nikoli skutečné selhání deserializace ani nativní podporu události.

Související lekce

  • JavaScript · Lekce 32 · Pokročilá · Verze: 4

Zdroje