mitmario.dev

Eigene Ereignisse

Node.js Sandbox 3 Min Lesezeit 3 BeispieleLektion 2 von 7

Aufträge landen in einer Warteschlange und werden abgearbeitet. Wer mitbekommen will, wann einer fertig ist, soll sich anhängen können. Mit einem EventEmitter als Eigenschaft ginge das. Nur müsste dann jeder Aufrufer wissen, dass er schlange.melder.on(…) schreibt und nicht schlange.on(…). Üblich ist ein anderer Weg. Die Klasse erbt vom EventEmitter, und damit meldet das Objekt selbst.

Eine Warteschlange, die selbst meldet
import { EventEmitter } from "node:events";

class Warteschlange extends EventEmitter {
  constructor() {
    super();
    this.auftraege = [];
  }

  hinzufuegen(name) {
    this.auftraege.push(name);
    this.emit("aufgenommen", name, this.auftraege.length);
  }

  abarbeiten() {
    while (this.auftraege.length > 0) {
      this.emit("erledigt", this.auftraege.shift());
    }
    this.emit("leer");
  }
}

const schlange = new Warteschlange();

schlange.on("aufgenommen", (name, offen) => console.log(`aufgenommen: ${name} (${offen} offen)`));
schlange.on("erledigt", (name) => console.log(`erledigt: ${name}`));
schlange.on("leer", () => console.log("nichts mehr zu tun"));

schlange.hinzufuegen("Rechnung");
schlange.hinzufuegen("Newsletter");
schlange.abarbeiten();

extends EventEmitter und ein super() im Konstruktor, mehr ist es nicht. Ab da hat deine Klasse on, once, emit und off, genau wie ein Server oder ein Stream. Von außen sieht dein Objekt damit aus wie ein eingebautes.

So ist auch die halbe Standardbibliothek gebaut. Wenn du in Abschnitt 8 createServer eine Funktion gibst, hängt Node sie als Listener an das Ereignis request. Dieselbe Mechanik.

Wie ein Ereignisname heißen sollte

Ein guter Ereignisname beschreibt, was passiert ist, nicht was der Listener tun soll.

auftrag-fertig ist gut. sende-bestaetigungsmail ist schlecht, obwohl an dieser Stelle vielleicht wirklich eine Mail rausgehen soll. Mit Geschmack hat das wenig zu tun. Es geht darum, wer wen kennt.

Bei auftrag-fertig weiß die Warteschlange nichts über Mails. Kommt später ein Listener dazu, der eine Statistik führt, ändert sich an ihr nichts. Bei sende-bestaetigungsmail hat die Warteschlange schon entschieden, was zu tun ist, und ein zweiter Listener für die Statistik hängt dann an einem Namen, der gar nicht zu ihm passt.

Die eingebauten Emitter halten es genauso. Ein Stream meldet data und end, ein Server request und close. Keiner meldet verarbeite oder antworte. Die Namen im ersten Beispiel sind genauso gebaut, also aufgenommen, erledigt und leer. Der Name gehört dem, der meldet, und nicht dem Listener.

Die Daten gehören ins emit

Es ist verlockend, das Ergebnis an eine Eigenschaft zu hängen und die Listener dort nachschauen zu lassen. Solange alle Listener sofort laufen, geht das auch gut. Sobald einer wartet, nicht mehr.

Daten an einer Eigenschaft gehen verloren
import { EventEmitter } from "node:events";

class Melder extends EventEmitter {
  melden(text) {
    this.letzteMeldung = text;
    this.emit("meldung");
  }
}

const melder = new Melder();

melder.on("meldung", () => console.log(`sofort: ${melder.letzteMeldung}`));
melder.on("meldung", async () => {
  await new Promise((fertig) => setTimeout(fertig, 10));
  console.log(`später: ${melder.letzteMeldung}`);
});

melder.melden("Erste Meldung");
melder.melden("Zweite Meldung");

Der zweite Listener wartet zehn Millisekunden. In dieser Zeit ist die zweite Meldung längst durch, und er liest zweimal denselben Wert. Die erste Meldung hat es für ihn nie gegeben.

Mit this.emit("meldung", text) und einem Parameter im Listener gibt es dieses Problem nicht. Jeder Aufruf bekommt seine eigenen Argumente. Und die bleiben auch dann richtig, wenn der Listener sich Zeit lässt.

Wo Ereignisse aufhören

Manchmal soll ein Ereignis etwas zurückliefern, etwa eine Summe, die ein Listener ausrechnet.

Was emit zurückgibt
import { EventEmitter } from "node:events";

const rechner = new EventEmitter();

rechner.on("rechne", (a, b) => a + b);

const rueckgabe = rechner.emit("rechne", 2, 3);

console.log(`emit gibt zurück: ${rueckgabe}`);
console.log(`emit ohne Listener: ${rechner.emit("gibtsnicht")}`);

emit gibt keinen Wert aus dem Listener zurück. Es liefert nur true oder false, je nachdem, ob überhaupt jemand zugehört hat. Die 5, die der Listener ausrechnet, ist weg. Bei einer async-Funktion wird genauso das Promise weggeworfen, und niemand wartet darauf.

Ereignisse sind für „ist passiert“, nicht für „gib mir“. Sobald du auf ein Ergebnis warten willst, ist ein Promise die richtige Wahl und kein Ereignis. Angenommen, abarbeiten aus dem ersten Beispiel wäre eine async-Methode und gäbe die Zahl der erledigten Aufträge zurück. Das wäre völlig in Ordnung, und melden könnte sie daneben trotzdem.

In der Praxis stehen die beiden deshalb oft nebeneinander. Der Aufrufer bekommt sein Ergebnis als Promise, und wer sonst noch mitbekommen will, was läuft, hängt sich an ein Ereignis.

In der Aufgabe lernt eine Aufgabenliste das Abhaken, und dabei soll sie melden.

Zum Mitnehmen

Auch eine selbst geschriebene Klasse kann Ereignisse melden, wenn sie EventEmitter erweitert. Ihre Ereignisse heißen nach dem, was passiert ist, die Daten reisen als Argumente von emit mit, und wer ein Ergebnis braucht, nimmt ein Promise.

Jetzt du

Basis Konto, kostenlos

Zu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.

Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.

In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.

Was in dieser Lektion steckt

  • Artikel mit 3 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe, dein Code läuft auf einem Server

    Öffnet sich mit dem Basis Konto.