Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / JavaScript

Worker: gestire `message`, `error` e `messageerror`

Distingui tre eventi di un worker dedicato: un messaggio ricevuto, un errore del worker e un messaggio che il destinatario non riesce a deserializzare.

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

Sintassi

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 e worker.onmessageerror sono proprietà per la gestione degli eventi sull’istanza Worker dedicata, dal lato che l’ha creata. Sono definite dallo standard HTML, non da ECMAScript 2024. Il supporto dipende dall’ambiente di esecuzione, soprattutto per messageerror. Imposta i gestori prima di inviare la prima richiesta.

onmessage riceve un MessageEvent quando un messaggio del worker viene deserializzato correttamente. Leggi il contenuto da event.data e verifica che abbia la struttura prevista dall’applicazione: la clonazione strutturata non convalida il tuo protocollo. Nel worker, self.onmessage gestisce la direzione opposta, cioè i messaggi dal contesto che l’ha creato.

onerror riceve un solo oggetto evento. Un’eccezione sincrona non intercettata e segnalata al contesto che ha creato il worker produce un ErrorEvent; non fare affidamento su event.error per ottenere l’eccezione originale. Un errore di caricamento dello script può produrre un semplice Event. Per un evento annullabile, event.preventDefault() può bloccare la propagazione della segnalazione, ma non riprende il codice interrotto. Nel worker, self.onerror ha una forma storica con cinque argomenti per ErrorEvent e può annullare la segnalazione con return true; questa regola non si applica a worker.onerror.

onmessageerror riceve un MessageEvent non annullabile anziché message se il destinatario non riesce a deserializzare il messaggio. Non c’è alcun contenuto decodificato da leggere. Passare una funzione a postMessage(), invece, genera DataCloneError in modo sincrono dal lato del mittente, senza causare messageerror dal lato del destinatario.

Ogni proprietà contiene un solo gestore: una nuova assegnazione lo sostituisce e null lo rimuove. Per registrare listener indipendenti, usa addEventListener() con il nome dell’evento senza on. Chiama worker.terminate() quando il worker non serve più; il metodo non attende che il lavoro in sospeso finisca.

Esempi

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

Risultato

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

Per provare le proprietà di gestione degli eventi dei Web Worker, esegui l’intero esempio nella console del browser su una pagina la cui politica di sicurezza consente worker `blob:`. Con Node.js 24, salva il codice come `main.cjs` ed esegui `node main.cjs`: questo ramo usa `node:worker_threads`, non le proprietà di gestione degli eventi del `Worker` del browser. In entrambi gli ambienti, `messageerror (synthetic)` verifica solo il gestore, non un vero errore di deserializzazione né il supporto nativo dell’evento.

Lezioni correlate

  • JavaScript · Lezione 32 · Avanzato · Versione: 4

Fonti