Abschnitt 7 · Lektion 2
Eigene Ereignisse
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.
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.
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.
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, kostenlosZu 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.