‫Jonas: Wie versprochen werden
‫wir nun in der Praxis Event-Emitter und -Listener einsetzen
‫und hier zunächst eine neue Datei erstellen.
‫Also Ereignisse. js und schließen Sie dieses.
‫Um die eingebauten Knotenereignisse zu verwenden,
‫benötigen wir also das Ereignismodul,
‫und
‫davon benötigen wir eine EventEmitter-Klasse.
‫EventEmitter, dies ist eine Art
‫Standardname für das Ergebnis, dass dieses Ereignismodul erforderlich ist.
‫Dies ist also wieder ein eingebautes Knotenmodul, okay?
‫Um nun einen neuen
‫Emitter zu erstellen, erstellen wir einfach eine
‫Instanz der Klasse, die wir gerade importiert haben.
‫Also ganz einfach
‫myEmitter ist ein neuer EventEmitter.
‫Also EventEmitter einfach so.
‫Denken Sie also an das letzte
‫Video, dass EventEmitters benannte Ereignisse aussenden können und
‫wir diese Ereignisse dann abonnieren können,
‫also im Grunde
‫auf sie hören und dann entsprechend reagieren, okay?
‫Es ist also ein bisschen so, als
‫würde man einen EventListener für ein dummes Element einrichten, zum
‫Beispiel für das Klicken auf eine Schaltfläche, und
‫ich bin sicher, Sie haben
‫dies schon einmal getan, wenn Sie mit JavaScript auf der Clientseite arbeiten, oder?
‫Unser Emitter wird also
‫irgendwann ein benanntes Ereignis aussenden, okay?
‫Also lass
‫uns das einrichten und einfach
‫so tun, als würden wir einen Online-Shop aufbauen oder so, okay?
‫Also können wir myEmitter sagen. emit(), und
‫dann können wir uns jeden beliebigen Eventnamen ausdenken, okay?
‫Wir wollen also ein Event namens newSale ausgeben, okay?
‫Und am Beispiel des Klickens
‫auf eine Schaltfläche, die
‫ich zuvor verwendet habe, ist dieses Senden hier, als würden wir auf
‫die Schaltfläche klicken, und jetzt müssen wir diese Hörer einrichten, okay?
‫Und lassen Sie mich
‫das hier vorher tun, und so verwenden wir wieder unser myEmitter-Objekt.
‫Geben Sie ein, dass wir die on-Methode verwenden, okay?
‫Also auf newSale und dann die Callback-Funktion , die
‫ausgeführt wird, sobald das Ereignis ausgegeben wird.
‫Kommen wir also wie immer einfach zur Konsole.
‫„Es gab einen neuen Verkauf! „Okay, und
‫lass uns noch einen hinzufügen.
‫Denken Sie also daran, dass ich
‫vorhin gesagt habe, dass eines der schönen Dinge an diesen Ereignis-Emittern darin besteht,
‫dass wir tatsächlich
‫mehrere Listener für dasselbe Ereignis einrichten können.
‫Also lass
‫uns das hier machen, und
‫so hören wir natürlich wieder auf
‫das newSale-Ereignis (tippen) und loggen
‫dann einfach etwas anderes.
‫Ist hier nicht wirklich wichtig.
‫Also '"Kundenname:', zum Beispiel 'Jonas''.
‫Testen wir dies also, löschen
‫wir das vorherige, und wir
‫verwenden Knoten
‫und dann Ereignisse. js.
‫Es gab also einen Verkaufs- und Kundennamen: Jonas, und
‫Sie sehen schon, dass es funktioniert.
‫Also, großartig, das ist also das Beobachtermuster, erinnerst du dich?
‫Wo dieser hier das Objekt ist, das die Ereignisse aussendet, und dann
‫diese beiden
‫hier, so weiter und weiter,
‫das sind die Beobachter.
‫Sie beobachten den
‫Emitter und warten, bis er das Ereignis newSale ausgibt.
‫Und natürlich könnte unser Emitter auch andere Events aussenden.
‫Zum Beispiel neuer Kunde oder neuer Auftrag oder
‫so ähnlich, und wir könnten dann auch Hörer hinzufügen, okay?
‫Eine andere Sache, die ich
‫Ihnen zeigen wollte, ist, dass wir sogar Argumente an den
‫EventListener übergeben können, indem
‫wir sie hier als zusätzliches Argument im Emitter übergeben.
‫Sagen wir also, dass neun passieren, in diesem Fall
‫also nur eine Zahl,
‫und wir haben dann einen Zuhörer, der das verwenden möchte.
‫(tippen) Also myEmitter,
‫(tippen) newSale, und
‫nun kann diese
‫Callback-Funktion
‫ein Argument annehmen, also nennen wir
‫es Bestand.
‫Also im Grunde die Menge an Artikeln, die
‫von dem Produkt übrig bleiben, das wir hier verkaufen.
‫Lassen Sie uns eine Vorlagenzeichenfolge verwenden.
‫Es
‫sind jetzt noch Lagerartikel auf Lager.
‫Wenn wir dies jetzt ausführen, sollten wir
‫also sehen, dass jetzt noch neun Artikel auf
‫Lager sind, da wir dieses Ereignis im
‫Wesentlichen mit einer Neun ausgegeben
‫haben, und der Listener kann diesen
‫Wert dann hier als Argument seiner Callback-Funktionen abrufen.
‫Also diese Bestandsvariable hier in diesem Fall.
‫Wenn Sie dies also noch
‫einmal ausführen, dann hier. Es sind noch neun Artikel auf Lager.
‫Also perfekt, und Sie sehen, dass diese drei
‫Protokolle hier in genau derselben Reihenfolge erscheinen, in der
‫sie im Code deklariert sind, okay?
‫Und das ist das normale Verhalten.
‫Wenn wir mehrere Listener für dasselbe Ereignis
‫haben, werden sie synchron ausgeführt.
‫Also nacheinander in der Reihenfolge, in der
‫sie im Code waren.
‫Dieses kleine Beispiel funktioniert also bereits
‫perfekt, aber wenn Sie dieses Muster im
‫wirklichen Leben verwenden, empfiehlt es sich, eine neue
‫Klasse zu erstellen, die tatsächlich vom Knoten EventEmitter erbt.
‫Also so etwas.
‫(Eingabe) Nehmen wir
‫an, die Klasse Sales erweitert EventEmitter, und das
‫ist die ES6- oder ES2015-Syntax für die Klassenvererbung.
‫Und noch einmal hoffe ich,
‫dass Sie zum Zeitpunkt des Kurses mit ES6 vertraut sind, okay?
‫Auswendig gesprochen ist der EventEmitter eine Klasse, also die, die
‫wir aus Events in unsere
‫Verkaufsklasse importiert
‫haben, ist die neue Klasse,
‫die wir erstellen und
‫die alles von der EventEmitter-Klasse erbt, okay?
‫Dann erhält in ES6 jede Klasse einen Konstruktor,
‫eine Funktion, die
‫ausgeführt wird, sobald wir ein neues Objekt aus einer Klasse erstellen, okay?
‫Und was wir hier tun müssen, ist Super
‫zu nennen, und das ist etwas,
‫was wir immer tun müssen, wenn wir eine andere Superklasse erweitern, okay?
‫Dies ist
‫also die Elternklasse und dies ist
‫die Superklasse, und indem
‫wir super ausführen, erhalten wir Zugriff auf alle Methoden der Elternklasse.
‫Also noch einmal EventEmitter in diesem Fall, okay?
‫Was wir jetzt tun müssen,
‫ist, diesen wirklich nach unten
‫zu verschieben (klicken)
‫und jetzt ist mein Emitter ein neuer Vertrieb, okay?
‫Und so wird es jetzt genau so
‫funktionieren, und tatsächlich, und tatsächlich
‫dieser Mechanismus, den ich Ihnen hier gerade gezeigt habe.
‫Das Erweitern der EventEmitter-Klasse ist also im Grunde
‫genau die Art und
‫Weise, wie die verschiedenen Knotenmodule, wie HTTP, Dateisystem und viele
‫andere Knotenkernmodule Ereignisse intern implementieren, okay?
‫Sie erben also
‫alle von der EventEmitter-Klasse.
‫Okay, und mit diesem kleinen Beispiel,
‫das funktioniert, versuchen wir jetzt tatsächlich etwas anderes.
‫Da ich gerade über das HTTP-Modul gesprochen
‫habe, möchte ich Ihnen zeigen,
‫dass es vollständig auf Ereignissen basiert, okay?
‫Also haben wir diesen Teil funktioniert.
‫Lassen Sie uns hier ein paar Kommentare erstellen, etwas,
‫und dann hier unten ein weiteres Beispiel erstellen, in Ordnung?
‫Und was wir tun
‫werden, ist, im Grunde einen kleinen Webserver
‫zu erstellen und dann tatsächlich auf das Ereignis zu hören, das er aussendet, okay?
‫Also, hier oben müssen wir das HTTP-Modul importieren
‫(tippen) Und dann
‫hier unten können wir es verwenden.
‫Also erstellen wir einen
‫Server, und jetzt werde ich es ein
‫bisschen anders machen als wir es in der ersten Kreuzung gemacht haben, okay?
‫Aber es funktioniert tatsächlich genau so.
‫Also alles, was ich hier tun werde, ist jetzt http. createserver und einfach so,
‫und jetzt
‫werde ich im Grunde
‫auf verschiedene Ereignisse hören, die der
‫Server ausgeben wird.
‫Dafür verwende ich wieder on, und
‫wenn Sie sehen, . an einer beliebigen Stelle
‫in einem Knotenprojekt, nun, dann wissen Sie
‫bereits, dass Sie zuhören oder dass der Code auf ein Ereignis wartet, okay?
‫Und das, was
‫wir hier hören, ist das Request-Ereignis, okay?
‫Und so funktioniert es jetzt genauso wie
‫zuvor, wir haben
‫eine Callback-Funktion, die Zugriff auf die Anfrage und die Antwort erhält.
‫Also nichts, was Sie zu diesem
‫Zeitpunkt im Node-Farm-Projekt getan haben, haben wir genau das getan, okay?
‫Also, Konsole. log
‫(eintippen) "Anfrage erhalten" und
‫dann schicken wir auch etwas zurück.
‫(tippt) Eigentlich
‫nur derselbe Text, okay?
‫Und natürlich können wir uns das
‫gleiche Ereignis mehrmals anhören.
‫(Klicken) Also sagen wir hier
‫einfach "Noch eine Anfrage" und verwenden
‫hier ein Emoji, nur damit es ein bisschen mehr auftaucht, und es
‫erscheint nicht.
‫Was ist hier los?
‫Ach, los geht's.
‫Hören Sie also auf
‫eine Anfrage, und wir können auch auf das Abschlussereignis hören.
‫Server beim Schließen, und das ist das Ereignis,
‫das ausgelöst wird,
‫wenn der Server, wie Sie sich vorstellen können, geschlossen wird.
‫(tippen) Okay, das ist
‫das Abhören der Ereignisse, und jetzt denken
‫Sie daran, wir
‫müssen auch den Server tatsächlich starten.
‫Also, und wir starten den
‫Server mit server. Hören Sie
‫zu, übergeben Sie den Port, die Adresse, die in
‫diesem Fall für uns wieder
‫localhost ist, Punkt eins, und dann unsere Callback-Funktion, die optional
‫ist, aber wir sie hier wieder einfügen.
‫(schreibend) "Warten auf
‫Anfragen... "Also,
‫lass uns damit anfangen
‫und wir sehen Warten auf Anfrage... und die Anwendung wird nicht heruntergefahren, und jetzt wissen
‫Sie, warum sie nicht heruntergefahren wird, oder?
‫Das liegt daran, dass die Ereignisschleife immer noch
‫auf eingehende E/A wartet, oder?
‫Das haben wir also in den Veranstaltungsschleifen-Vorträgen gelernt, okay?
‫Lassen Sie uns nun tatsächlich eine Anfrage auf Port 8000 auf dieser URL durchführen.
‫(klicken) (tippen) Und
‫los geht's.
‫Wir sehen also Anfrage erhalten.
‫Das funktioniert also, denn sobald es eine neue
‫Anfrage gibt, sendet der Server automatisch das Anfrageobjekt, okay?
‫Und das sehen wir natürlich hier und hier in der
‫Konsole sehen wir unseren Request
‫Received String.
‫Eigentlich wollte ich mir hier noch einen zulegen.
‫Daher können wir natürlich nur eine Antwort senden.
‫Also hier sollte ich eine andere Konsole haben. log stattdessen.
‫Also lassen, beenden, neu starten, neu
‫laden und, ja, jetzt bekommen wir Request empfangen, der
‫von
‫diesem ersten EventListener kommt, und einen
‫weiteren Request von diesem zweiten EventListener.
‫Eine Sache, die Ihnen wahrscheinlich auffällt, ist, dass jede dieser hier
‫tatsächlich zweimal protokolliert wird.
‫Das bedeutet also, dass der Server das
‫Anforderungsereignis tatsächlich auch zweimal ausgibt.
‫Mal sehen, warum das so ist.
‫(tippt)
‫Also Konsole. protokollieren, anfordern. url.
‫Damit können wir nun
‫auf die URL der Anfrage zugreifen.
‫(klicken) Lass uns
‫hier aufhören.
‫Führen Sie es erneut
‫aus, laden Sie es
‫neu, und
‫so haben wir eine für die Root-URL und dann eine für das Favicon. ico Browser versuchen also automatisch, für
‫jede Website
‫ein Favicon anzufordern, okay?
‫Deshalb ist jeder von ihnen tatsächlich zweimal aufgetaucht, okay?
‫Sie sehen also, dass wir nicht immer auch
‫Ereignisse ausgeben müssen.
‫Dies gilt umso mehr, wenn wir versuchen, den EventEmitter allein zu verwenden.
‫Im Grunde also, wenn wir versuchen, unsere benutzerdefinierten Ereignisse in
‫unseren Anwendungen zu verwenden.
‫In diesem Fall müssen wir die
‫Ereignisse
‫natürlich selbst ausgeben, aber wenn wir ein
‫eingebautes Node-Modul verwenden, geben diese Funktionen oft
‫ihre eigenen Ereignisse aus, und wir müssen
‫uns nur anhören Ihnen.
‫Genau das haben wir hier gemacht, und
‫damit, denke ich, weißt du jetzt alles, was du
‫über Veranstaltungen wissen
‫musst, und bist bereit, mit mir zum nächsten Video zu kommen.