Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / JavaScript

Worker : gérer `message`, `error` et `messageerror`

Distinguez trois événements d’un worker dédié : un message reçu, une erreur du worker et un message que le destinataire ne peut pas désérialiser.

Version : 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 et worker.onmessageerror sont des propriétés de gestion d’événements sur l’instance Worker dédiée, du côté qui l’a créée. Elles relèvent du standard HTML, pas d’ECMAScript 2024. Leur prise en charge dépend de l’environnement, en particulier pour messageerror. Installez les gestionnaires avant d’envoyer la première requête.

onmessage reçoit un MessageEvent lorsqu’un message du worker est désérialisé avec succès. Lisez le contenu dans event.data et vérifiez qu’il a la structure attendue par l’application : le clonage structuré ne valide pas votre protocole. Dans le worker, self.onmessage gère le sens inverse, c’est-à-dire les messages envoyés par le contexte créateur.

onerror reçoit un seul objet événement. Une exception synchrone non interceptée signalée au contexte créateur donne un ErrorEvent ; ne supposez pas que event.error contient l’exception d’origine. Un échec de chargement du script peut donner un simple Event. Si l’événement est annulable, event.preventDefault() peut empêcher la poursuite du signalement, sans reprendre l’exécution du code interrompu. Dans le worker, self.onerror a une forme historique à cinq arguments pour ErrorEvent et peut arrêter le signalement avec return true ; cette règle ne s’applique pas à worker.onerror.

onmessageerror reçoit un MessageEvent non annulable à la place de message lorsque le destinataire ne peut pas désérialiser le message. Il n’y a alors aucun contenu décodé à lire. En revanche, passer une fonction à postMessage() lève DataCloneError de façon synchrone du côté émetteur, sans déclencher de messageerror chez le destinataire.

Chaque propriété contient un seul gestionnaire : une nouvelle affectation le remplace et null le retire. Utilisez addEventListener() avec le nom de l’événement sans on pour inscrire des écouteurs indépendants. Appelez worker.terminate() quand le worker n’est plus nécessaire : cette méthode n’attend pas la fin du travail en cours ou en attente.

Exemples

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

Résultat

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

Pour essayer les propriétés de gestion d’événements d’un Web Worker, exécutez l’exemple complet dans la console d’un navigateur, sur une page dont la politique de sécurité autorise les workers `blob:`. Avec Node.js 24, enregistrez-le sous `main.cjs` et lancez `node main.cjs` : cette branche utilise `node:worker_threads`, et non les propriétés de gestion d’événements du `Worker` du navigateur. Dans les deux environnements, `messageerror (synthetic)` ne teste que le gestionnaire, pas un véritable échec de désérialisation ni la prise en charge native de l’événement.

Leçons associées

  • JavaScript · Leçon 32 · Avancé · Version : 4

Sources