In der vorherigen Übung
haben wir zwei neue Aspekte von JavaScript gelernt,
ihre Unterstützung für erstklassige Funktionen und Schließungen.
Wir haben auch gesehen, wie Node den asynchronen Programmieraspekt behandelt und wie Node
asynchrone Ausführung von Code mit
der Verwendung von Callbacks und auch Fehlerbehandlung unterstützt.
Sehen wir uns ein Beispiel an, wie wir dies
innerhalb unserer Node-Anwendung in dieser Übung nutzen.
Fortsetzung, wo wir in der vorherigen Übung aufgehört haben,
jetzt werde ich gehen und das Rechteck-Knoten-Modul ändern,
so dass es die Hilfe von Callbacks nehmen kann.
Also werde ich diese Exporte hier entfernen,
und stattdessen werden sie diese Funktion ändern.
Ich werde diese beiden Funktionen ein wenig später nutzen,
also speichere ich sie unten.
Also lassen Sie mich sie beiseite halten.
Und dann werde ich dieses Rechteck-Modul wie folgt ändern.
Also sagen wir module.exports.
Wir verwenden also die Standardweise, wie das Modul gehandhabt wird.
Und dies wird diese Funktion exportieren, die diese drei Parameter,
x und y und Callback nimmt.
Der Callback ist eine Funktion, die geliefert wird, wenn dieses Modul aufgerufen wird.
Dies ist also die Verwendung der erstklassigen Funktionen, über die wir früher gesprochen haben.
In diesem Callback
können Sie also sehen, dass Sie zwei Parameter erhalten, x und y.
In diesem Fall
entsprechen die x und y für das Rechteck der Länge und Breite
des Rechtecks, das als die beiden Werte übergeben wird.
Also hier drinnen werden wir überprüfen,
ob x kleiner oder gleich Null ist oder y kleiner oder gleich Null ist oder gleich Null ist.
Wir haben Code wie diesen hier geschrieben.
Also werde ich diesen Code von hier kopieren
und ihn dann hierher bringen und dann bearbeiten wir es.
In diesem Fall ist dies, wenn x
kleiner oder gleich Null ist oder y kleiner oder gleich Null ist.
In diesem Fall, was tun wir?
In diesem Fall stellen wir fest, dass
die Abmessungen des Rechtecks kleiner oder gleich Null sind.
Also müssen wir es anders handhaben,
und wir werden den anderen Teil davon machen.
Der andere Teil, in dem wir die Situation behandeln, in der das Rechteck ein gültiges Rechteck ist.
Also in diesem Fall,
was wir tun werden, ist, dann ein setTimeout zu verwenden.
Also hier simuliere ich die Tatsache, dass alles, was
in diesem Rechteck getan wird, einige Zeit in Anspruch nehmen wird.
Dies ist also die asynchrone Verarbeitung.
Jetzt, da ich im Hintergrund nicht viel zu tun habe,
werde ich dies simulieren, indem ich einfach
die setTimeout-Funktion von JavaScript verwende und dann
verzögere, bevor die Callback-Funktion aufgerufen wird.
Die Art und Weise, wie ich das arrangiere, ist wie folgt.
Also innerhalb des setTimeout
werde ich diese Funktion dort aufrufen
und eine Verzögerung von
2.000 Millisekunden oder zwei Sekunden anordnen, nach denen diese Funktion aufgerufen wird.
Wenn Sie sich also erinnern,
das SetTimeout, das in JavaScript unterstützt wird,
nimmt es als erster Parameter eine Funktion und
der zweite Parameter wäre der Zeitraum, für den dies verzögert wird.
Also lassen Sie mich das einrücken.
Jetzt muss ich diese Funktion hier ausfüllen.
Also habe ich hier mit der Pfeilfunktion begonnen
, die keine Parameter annimmt und dann, wenn es aufgerufen wird,
werde ich einen Aufruf an den Callback ausgeben.
Dieser Callback ist eine Callback-Funktion,
die hier als dritter Parameter übergeben wird.
Diese Callback-Funktion, wie Sie bemerkt haben, nimmt zwei Parameter.
Der erste ist der Fehler und der zweite ist der Rückgabewert.
Also in diesem Fall, da wir einen Fehler haben,
weil x kleiner oder gleich Null ist und y kleiner oder gleich Null ist,
also der erste Wert, den ich als neuer Fehler übergeben werde,
und dieser Fehler ist genau diese Zeichenfolge, die ich dann in der console.log verwendet habe,
und das ist, was ich als der Fehler hier.
Lassen Sie mich jetzt die console.log löschen,
ich brauche sie nicht mehr.
Also für den Callback
werde ich ein neues Fehlerobjekt generieren und dann
als Rückgabewert für die Callback-Funktion, den ersten Parameter, übergeben.
Also werde ich sagen, Rechteck-Dimensionen sollten größer als Null sein.
Also sagen wir l,
das ist der x und der y-Wert, den wir als Eingabewerte dort bekommen haben.
Das ist also der Rückruf.
Und der zweite Teil dieses Rückrufs
werde ich als null übergeben, weil dies einen Fehler zurückgeben wird.
Wenn Sie also einen Fehler als ersten Parameter zurückgeben,
wird der zweite Parameter ignoriert, wenn dieser Rückruf gerade vom
Knotenmodul empfangen wurde, von dem wir diese bestimmte Funktion dort aufrufen.
Also, mit dieser Anordnung,
also weniger als Null,
lassen Sie mich hier etwas Platz geben, damit es hier richtig eingerückt ist.
Also, die Art und Weise, wie ich dies
hier arrangiere, ist, dass, wenn x kleiner als Null ist und y kleiner als Null ist,
ich die Callback-Funktion zurückrufen werde, die übergeben wurde,
aber der erste Parameter wird
irrtümlich übergeben, weil wir hier bemerken, dass es einen Fehler gibt,
und der zweite Parameter wird null sein.
Wenn dies nicht der Fall ist
, rufe ich den gleichen Callback auf,
aber mit dem ersten Parameter.
Also lassen Sie mich den Code hier kopieren.
Ich werde immer noch das setTimeout hier verwenden.
Aber dieser erste Teil wird kein Fehler sein
, sondern der erste Teil,
in diesem Fall gibt es keinen Fehler.
Also werde ich diesen Wert einfach als null zurückgeben.
Das bedeutet also, dass der Fehler auf null gesetzt ist.
Dies ist also ein gültiges Rechteck.
So können wir die Werte für das Rechteck berechnen.
Aber stattdessen werde ich einfach
ein JavaScript-Objekt übergeben, das die beiden Funktionen
als die beiden Werte in diesem JavaScript-Objekt enthält.
Also, hier werde ich diese zwei nehmen,
den Umfang und das Gebiet,
und dann werden diese beiden als die beiden Werte hier übergeben werden,
Umfang und Gebiet.
Und diese beiden, da sie ein JavaScript-Objekt sind, werden
Umfang und Bereich
die beiden Eigenschaften sein, die ich in diesem JavaScript-Objekt übergeben werde,
und das ist es.
Also hier, im zweiten Fall,
wird der Fehler auf null gesetzt, weil es keinen Fehler gibt,
aber der zweite Teil,
beachten Sie, dass ich ein JavaScript-Objekt übergeben, das zwei Eigenschaften enthält,
Umfang und Fläche, die hier zwei Funktionen sind.
Die beiden Funktionen sind also die Perimeter-Funktion und Flächenfunktion.
Dieses JavaScript-Objekt wird also als
Rückgabewert für den Callback hier, der zweite Wert, zurückgegeben.
Und wieder werde ich dies um
ein zwei-Sekunden-Intervall verzögern, bevor der Wert von dieser Funktion zurückgegeben wird.
Der Grund, warum ich das setTimeout verwende, besteht darin,
eine Verzögerung zu simulieren, bevor der Callback von der anderen Seite kommt.
Diese Art von stellt also Situationen dar, in denen
Sie beispielsweise einen Datenbankaufruf an die Datenbank ausgeben
und die Datenbank gelesen werden muss, bevor der Wert an Sie zurückgegeben wird.
Das wird also eine gewisse Zeit in Anspruch nehmen.
Also simuliere ich dies in diesem Moment im Grunde, indem ich hier die setTimeout-Funktion verwende.
Später werden Sie sehen, dass, wenn wir die MongoDB mit
unserem Express in den späteren Übungen integrieren,
diese Verzögerung simuliert werden müsste,
sie wird automatisch verursacht, weil Sie
Datenbankoperationen hinter den Kulissen durchführen müssen, bevor die Daten abgerufen werden.
Also hier, nachdem Sie dieses Rechteck-Modul-Update abgeschlossen haben,
sehen Sie hier, dass das Rechteck-Modul
drei Parameter übernimmt, da es hier ein Eingabeaufruf ist,
x, y und Callback.
Und so ist der Callback die Callback-Funktion, die hier bereitgestellt wird.
Und diese Callback-Funktion wird hier im Inneren aufgerufen,
und wenn die Callback-Funktion aufgerufen wird,
geben Sie entweder einen Fehler zurück oder Sie geben
eine Funktion zurück, mit der Sie den Umfang und die Fläche des Rechtecks berechnen können.
Nun, dieses Muster des Aufrufs und Übergabe einer Callback-Funktion
von einem Node-Modul und dann dem zweiten Node-Modul, das, wenn es abgeschlossen ist,
das Ergebnis mit der Callback-Funktion zurückgibt, ist
genau das Muster, das Sie oft in Node-Anwendungen wiederholt sehen werden.
Das ist der Grund, warum ich es illustriere.
Natürlich ist dies ein erfundenes Beispiel, das ich hier illustriere, aber es zeigt
alle Standardmuster, die Sie mit Knoten-
und Callback-Funktionen und auch die Fehlerbehandlung verwenden werden.
Jetzt haben wir das Rechteck-Modul hier aktualisiert.
Lassen Sie uns gehen und beheben Sie die Datei index.js, so dass sie die Callback-Funktion übergeben und
dann den Rückgabewert behandeln kann, der vom Rechteck-Modul zurückgesendet wird.
Wechseln Sie zurück zu index.js,
jetzt werden wir die index.js Datei wie folgt aktualisieren.
Ich werde dies stattdessen aus der Datei index.js entfernen.
Hier, was wir am Ende tun werden, ist
dieses Rechteck-Modul aufrufen und
dann die l und die b als die beiden Parameter übergeben.
Und der dritte Parameter, den ich übergeben werde, ist diese Callback-Funktion.
Die Callback-Funktion hat also zwei Parameter, err und rechteck.
Und diese Callback-Funktion ist hier wie folgt implementiert.
Hier sehen Sie, dass ich
dieses Rechteck-Knoten-Modul aufrufe und ich
die Länge und die Breite der ersten beiden Parameter übergebe.
Und der dritte Parameter ist natürlich
eine Callback-Funktion, die ich hier implementiere.
Also, das ist eine Pfeilfunktion, die ich hier implementiere.
Also,
wie handle ich in dieser Callback-Funktion mit dem Rückgabewert?
Also hier werde ich sagen, wenn (err),
also wenn der Fehlerwert an Sie zurückgegeben wird,
dann werde ich einfach console.log machen und ich werde
„ERROR“ sagen und dann ist der zweite Wert err.message.
Erinnern Sie sich, dass
wir im Rechteck dieses neue Fehlerobjekt erstellt
und dann diese Zeichenfolge innerhalb dieses Fehlerobjekts übergeben hatten.
Diese Zeichenfolge wird
hier an das Error-Objekt an die message-Eigenschaft des Error-Objekts angehängt.
Also, in der Datei index.js,
also rufe ich die Nachrichteneigenschaft des Fehlerobjekts ab
und drucke sie dann hier auf meine Konsole aus.
Wenn also ein Fehler auftritt,
werde ich die Fehlermeldung mit diesem ausdrucken.
Und so würde ich mit einem Fehler umgehen, der von einer Callback-Funktion zurückgegeben wurde.
Andernfalls
hat das Rechteck-Modul natürlich in diesem Fall die Rechteck-Funktion zurückgegeben,
das Objekt, das den Umfang und die Flächenfunktionen enthält,
so dass ich diesen Wert ausdrucken kann.
Also, hier werde ich sagen, die Fläche
des Rechtecks der Dimensionen l gleich,
also werde ich sagen,
und b gleich.
Der Grund, warum ich es
explizit identifiziere, wird sehr klar, wenn wir dieses Beispiel ausführen.
Ich werde sagen, ist rechtwinklig. Bereich.
Nun, beachten Sie, dass für diesen Bereich,
Ich schicke hier keine Parameter, weil geht zu Werten,
die Länge und der Atem wurden bereits hier in der l und b übergeben,
und diese wären bereits verfügbar für diese
und hier wegen der Schließung, die JavaScript unterstützt.
Da diese x und y als Parameter eingegangen sind,
sind diese direkt dort in dieser Callback-Funktion zugänglich.
Diese x_y werden also automatisch für uns hier zur Verfügung stehen.
Also, in der Tat
muss ich diese x- und y-Parameter hier überhaupt nicht angeben, weil
diese x und y von diesem x und y direkt dort abgerufen werden.
Also muss ich nicht einmal diese beiden Werte hier drin übergeben.
Deshalb, genau da,
kann ich rectangle.area anrufen.
Und diese Flächenberechnung wird automatisch die l und b erhalten, die
vom Rechteck-Aufruf an das direkte Knotenmodul früher übergeben wurden.
Dies ist also die Schließung von JavaScript, das hier funktioniert.
Also, das ist der erste.
Ich drucke den Bereich des Rechtecks aus.
Das Gleiche, lassen Sie mich auch die Umfänge ausdrucken.
Also, um die Umfänge auszudrucken,
so werde ich console.log sagen.
Der Umfang des Rechtecks wird Rechteck Umfang sein.
Jetzt muss ich Ihnen sagen, dass diese Art von Ansatz für die Implementierung ein wenig
Aufwand erfordert, um die asynchrone Funktionsfähigkeit zu verstehen und zu verinnerlichen. Es
braucht einige Zeit, um vollständig zu verstehen, wie es wirklich funktioniert.
Nun, um die Tatsache zu veranschaulichen, dass
dieser Funktionsaufruf zu einem Aufruf des Node-Moduls führt,
aber dieser Teil wird erst nach
einer zwei-Sekunden-Verzögerung ausgeführt, da wir die eingestellte Zeitmarke verwenden.
Nun, da wir im asynchronen Betrieb studiert
haben, weil wir die Verarbeitung nach hinten verschoben haben,
lassen Sie mich hier auch eine weitere console.log vorstellen, um einen Punkt zu machen.
Also sagen wir, diese Aussage ist
nach dem Aufruf von rect.
Der Grund, warum ich diesen Punkt illustriere, ist, dass, wenn Sie diesen Aufruf ausführen,
dieser Code erst nach einer zwei-Sekunden-Verzögerung ausgeführt wird.
In der Zwischenzeit
wird Ihre Funktion, die Hauptfunktion hier, fortgesetzt und dann die nächste Codezeile ausführen, die Sie hier sehen.
Das ist also die Fortsetzung, die Sie hier sehen werden.
Also, mit diesen Änderungen,
lassen Sie uns die Änderungen speichern und dann schauen, wie diese Anwendung jetzt ausgeführt wird.
So speichern Sie die Änderungen.
Gehen wir zum Terminal und führen Sie diese Knotenanwendung aus.
Gehen Sie nun zum Terminal und fügen Sie die Eingabeaufforderung hinzu.
Lassen Sie mich npm start eingeben und Sie werden sofort bemerken
, dass die Lösung und diese Aussage früher ausgedruckt wurden.
Und dann nach dieser gewissen Verzögerung wurden
das Gebiet und der Umfang ausgedruckt.
Das ist also eine Verzögerung von zwei Sekunden, die wir mit dem festgelegten Timeout eingeführt haben.
Sie haben also bemerkt, dass in der früheren Version
dies gedruckt wurde und sofort der Bereich und der Umfang direkt darunter gedruckt wurden.
Aber jetzt, beachten Sie, dass diese Werte ein wenig später gedruckt werden.
Dazwischen ruft ihre Funktion mit den verschiedenen Parametern auf, die bereits eingegangen sind,
und dann werden die Callbacks nach zwei Sekunden Verzögerung für jeden von ihnen zurückgerufen.
Und aufgrund der Tatsache, dass es die Schließung gibt, die das JavaScript unterstützt,
so dass die Werte, die übergeben werden, erhalten bleiben.
Und so, wenn die Callback-Funktion aufgerufen wird,
wird der entsprechende Wert gedruckt.
Deshalb sehen Sie, dass die Fläche und
der Umfang korrekt gedruckt sind und diese beiden hier,
diese beiden Aussagen hier,
entsprechen diesem speziellen Aufruf zu direkter
mit l gleich zwei und b ist gleich vier.
Und dann
entsprechen diese beiden, die nächsten zwei, natürlich dieser besonderen und den übrigen, wie Sie hier sehen.
Was ich also veranschaulichen wollte, ist die Tatsache, dass bei asynchroner Berechnung
die asynchrone Berechnung ihre eigene Zeit benötigt,
um den Wert zurückzugeben, während Ihre Hauptrechnung
vorwärts fortgesetzt wird, ohne auf den Abschluss des Callbacks zu warten.
Also, wenn Sie eine bestimmte Menge an Arbeit tun müssen,
haben Sie als Rückruf an dieses andere Modul übergeben.
Und wenn dieses andere Modul seine Arbeit abgeschlossen hat,
wird es zurückgerufen und dann wird dieser Code ausgeführt.
Das ist also der Punkt, den ich anhand dieses Beispiels illustriert habe.
Wieder, wie ich sagte, erfordert dies ein wenig Phantasie und Verständnis
für Sie, um die Art und Weise zu verinnerlichen, wie dies funktioniert,
aber Sie werden sehen, dass mit Node und auch Express und wenn wir MongoDB verwenden,
werden Sie sehen, dass sich diese Art von Muster sehr oft in der Art und Weise wiederholen, wie wir unseren Code schreiben.
Mit dieser einfachen Abbildung von Callbacks und Fehlerbehandlung
schließen wir diese Übung ab.
Dies ist ein guter Zeitpunkt für Sie, einen get Kommentar mit dieser Nachricht,
Knoten, Rückrufe und Fehlerbehandlung zu tun.