In dieser Übung werden wir mit der vorherigen Übung fortfahren, in der wir
die Interaktion zwischen der Knotenanwendung und dem MongoDB-Server entwickelt haben.
In dieser Übung werde ich einige der
Datenbankoperationen in ein eigenes Knotenmodul,
ein dateibasiertes Knotenmodul, kapseln
und es dann innerhalb meiner Knotenanwendung verwenden, um mit dem Server zu interagieren.
Gleichzeitig führen wir mehrere Operationen auf
dem Server durch, um zu demonstrieren, dass wir
mit dem Server interagieren können, indem wir unsere Knotenanwendung und den Knoten MongoDB-Treiber verwenden.
Um zu beginnen, gehen wir zu unserem Projekt
und erstellen Sie dann eine neue Datei namens operations.js.
Diese Datei kapselt alle Datenbankoperationen,
die vier Operationen, die ich ausführen werde einfügen,
finden, entfernen und aktualisieren Sie ein Dokument in meiner Datenbank.
Nun wird dies als dateibasiertes Knotenmodul organisiert,
das ich dann in meiner Knotenanwendung verwenden werde, um auf den Server zuzugreifen.
Um loszulegen, lassen Sie
mich zuerst Assert
in diesem Knotenmodul benötigen,
und da dies ein Knotenmodul ist,
werden wir mehrere Methoden aus dem Knotenmodul exportieren.
Die erste Methode wäre das Einfügen Dokument offensichtlich, wie Sie es erwarten würden,
und dies wird vier Parameter DB nehmen,
die MongoDB, Datenbankverbindung innerhalb meiner Knotenanwendung,
die ich innerhalb der Knotenanwendung erhalten werde.
Dann ist das zweite das Dokument, das ich einfügen möchte.
Der dritte Parameter ist die Sammlung, in die ich das Dokument einfügen möchte.
Die letzte ist eine Callback-Funktion,
die zurückgerufen wird, sobald diese Operation abgeschlossen ist.
Dann schließen wir die Funktion hier,
und dies kapselt im Wesentlichen die Einfügedokumentmethode hier.
Dies ist also eine Funktion, die von diesem Knotenmodul hier exportiert wird.
Nun werde ich hier auch ein paar weitere Methoden einbinden.
Der zweite wäre Finddocuments.
Nicht nur ein, sondern mehrere Dokumente.
Dies würde ich die Sammlung durchsuchen und alle Dokumente finden, die in der Sammlung sind.
Deshalb nehme ich nur die Datenbank
und die Sammlung als die beiden Parameter zusammen mit dem Callback.
Die dritte Funktion, die ich von hier aus implementieren werde, ist das removedocument.
Dies unterstützt den Löschvorgang,
und so nimmt der Name des Dokuments die Datenbank, das Dokument,
die Sammlung und den Rückruf als die vier Parameter,
und wir rufen den Callback auf, wenn der Vorgang abgeschlossen ist.
Die letzte ist natürlich, das Dokument zu aktualisieren.
Natürlich müssen Sie es nicht unbedingt so machen.
Ich hatte nur das Gefühl, dass dies eine andere Möglichkeit wäre, zu veranschaulichen, wie Sie
diese Funktionen in ein eigenes Knotenmodul einkapseln können.
Dies ist nur die Reorganisation des Codes auf eine Weise, die einfacher zu verwenden ist.
Also, für die Exporte,
für das Update-Dokument braucht es die DB,
eine Möglichkeit, das Dokument als zweiten Parameter zu identifizieren.
Der dritte Parameter ist die Aktualisierung,
und der vierte Parameter ist die Sammlung, in der
dieses Dokument vorhanden ist, und der Rückruf.
Also, vier Funktionen, die von der Datei operations.js exportiert werden.
Nun, innerhalb dieser Funktionen,
lassen Sie uns eins nach dem anderen implementieren.
Im Einfügedokument
ist das erste, was ich tun werde,
const collection zu sagen und es wird DB Sammlung sagen,
und der Parameter ist die Sammlung.
Also, wir werden dort nach der Sammlung suchen.
Nun, dies muss in allen vier Methoden durchgeführt werden.
Also, ich werde gehen und diesen Code in alle vier Methoden hier einfügen,
weil das eine Funktion ist, die ich in allen von ihnen brauche.
Also, sobald ich die Sammlung erhalte,
kann ich, wie Sie sich aus der vorherigen Übung erinnern, Operationen an der Sammlung durchführen.
Also, ich sage Sammlung, Einfügen,
und dies nimmt als ersten Parameter das einzufügende Dokument,
und der zweite Parameter ist der Callback mit dem Fehler und diesem Ergebnis.
Also, jetzt, wenn dieses Dokument
durch Aufruf der Insert-Methode für die Datenbanksammlung eingefügt wird,
lassen Sie mich die Insert-Methode erinnern,
wird vom MongoDB-Treiber unterstützt.
Also, das ist die Methode, die wir hier verwenden,
oder das ist die Funktion, die wir hier verwenden.
Nun, das erste, was ich nach diesem überprüfen werde, assertequal irr, null.
Also möchte ich sicherstellen, dass ich keinen Fehler habe.
Also möchte ich sicherstellen, dass der Fehler null ist.
Wenn es nicht null ist,
wird dies die Informationen ausdrucken und dann die Anwendung beenden.
In diesem Moment denke ich, dass dies in Ordnung ist, um damit umzugehen, dass
wir später sehen werden, wie wir eine globale Methode haben können, alle Fehler zu behandeln, wenn wir
in der nächsten Lektion eine andere Möglichkeit des Zugriffs auf die MongoDB-Datenbank implementieren.
Nun, nachdem ich das getan
habe, werde ich implementieren,
werde ich diese Informationen einfach protokollieren.
Also werde ich sagen, Konsolenprotokoll und fügen Sie es ein.
Also, diese Information wird hier auf den Bildschirm ausgedruckt, eingefügt.
Erinnern Sie sich an die Semikolons und alles, was
wichtig ist, vergessen Sie sie nicht, wenn Sie Ihren Code eingeben.
Also, ich werde sagen, eingefügt Ergebnis.
Dieses Ergebnisobjekt, das zurückgegeben
wird, hat eine Eigenschaft namens Ergebniseigenschaft,
und diese Eigenschaft enthält einen Wert.
Diese Ergebniseigenschaft ist auch ein JavaScript-Objekt,
und dies wird eine Eigenschaft n enthalten, die uns mitteilt, wie viele Dokumente eingefügt wurden.
Das sind also die Informationen, die ich hier ausdrucken
werde, und dann gehen wir zur nächsten Zeile und
sagen „Dokumente in die Sammlung“.
Nun, dies ist nur eine Möglichkeit, den Benutzer zu informieren, dass diese Operation korrekt stattgefunden hat,
und dann werden sie dieses Ergebnis an unsere aufrufende Funktion übergeben.
Also, wir rufen den Callback auf und dann wird das Ergebnis der Parameter für den Callback sein.
Wenn wir also die Verwendung dieser Funktion in unserer Datei index.js implementieren,
werden wir dort den Rückruf bereitstellen, der
das Ergebnis als eingehender Parameter erhält.
Dies ist also für das „InsertDocument“.
Nun, für das „FindDocument
“, was ich tun werde, ist zu sagen,
„coll.find“ und ich werde alle Dokumente finden.
Also, deshalb werde ich hier ein leeres JavaScript-Objekt geben,
das mit allen Dokumenten in der Sammlung übereinstimmt und dann werde ich sagen,
„ToArray“ und dies wird als Parameter eine Callback-Funktion nehmen,
und innerhalb dieser Callback-Funktion
werde ich natürlich behaupten, dass dies nicht null ist,
und dann werden wir sagen, „Callback docs.“
Wir werden die abgerufenen Dokumente einfach an die aufrufende Funktion zurückgeben.
Nun, für das „RemoveDocument“, werde ich sagen, „Sammlung DeleteOne.“
Also werde ich versuchen, das erste Dokument zu finden, das
mit dem übereinstimmt, was wir angegeben haben, und dann löschen.
Und dann wird dies wiederum
eine Callback-Funktion als zweiter Parameter nehmen,
und innerhalb dieser Callback-Funktion
überprüfe ich zuerst, um sicherzustellen, dass der Fehler nicht null ist.
Und dann werden wir sagen,
„Konsolenprotokoll entfernt das Dokument Komma Dokument.“
Wir haben das Komma hier verwendet, weil dies ein JavaScript-Objekt ist.
Wenn Sie also Konsolenprotokoll wie folgt angeben,
wird das Dokument ausgedruckt und dann werden wir dieses
Ergebnis durch die Callback-Funktion zurückgeben.
Und dann schließlich, für das Update werden wir coll.UpdateOne.
Dies ist eine Methode, die der MongoDB-Treiber unterstützt.
Also, ich werde sagen, „update.Ein Dokument
“, und der zweite Parameter ist, wo wir
in den Feldern übergeben, die aktualisiert werden müssen.
Und so wie es gemacht wird
, sagen wir: „Dollarsatz Doppelpunkt aktualisieren“.
Also, dies wird die Update-Informationen, die
ich schicke, nehmen und dann in das update.one übergeben.
Das erste ist das Dokument, das aktualisiert werden muss.
Die zweite ist, welche Felder des Dokuments hier aktualisiert werden müssen.
Und der dritte Parameter ist null,
und dieser letzte Parameter ist eine Callback-Funktion,
die uns offensichtlich das Ergebnis der Operation gibt.
Also, zuerst werde ich überprüfen, um sicherzustellen, dass der Fehler nicht null ist.
Dann werde ich eine „Konsolenprotokoll aktualisiert das Dokument mit.“
Nun wieder, die Konsolenprotokolle sind rein für uns, um
sicherzustellen, dass der Code tut, was er tut.
Es hilft in keiner Weise.
Dies ist nur zu unseren eigenen Informationen.
In einem Produktionsserver
würden Sie vielleicht keine Konsolenprotokolle haben.
Sie können sie deaktivieren. Also, das war's.
Also vier Methoden, die in diesem speziellen dateibasierten Knotenmodul unterstützt werden, einfügen,
finden, entfernen und aktualisieren.
Also, jetzt, da wir dieses dateibasierte Knotenmodul implementiert haben,
gehen wir zur Datei index.js,
und dann, um dieses dateibasierte Knotenmodul
zu verwenden, muss ich dies hier benötigen.
Also, ich werde sagen, „const dboper erfordern.“
Da dies ein dateibasiertes Knotenmodul ist, erhalten Sie den vollständigen Pfad zum Knotenmodul,
und was in diesem Fall passiert. /operations
, weil es sich im selben Ordner wie meine Datei index.js befindet.
Nun, sobald wir dies getan haben,
dann genau hier, diese Funktion,
dieser Code, den wir getan haben, um auf die Datenbank zuzugreifen jetzt einfügen,
werden wir den DBoper verwenden, den wir gerade implementiert haben, um auf diese Datenbank zuzugreifen.
Also, wir werden sagen, „dboper insert document
“, und dieses „insert document“ nimmt die db als ersten Parameter.
Die db hier, ist diese db, die kam, wenn wir MongoClient connect aufrufen.
So dass db übergeben wird, so dass
mein Betriebsknotenmodul weiß, wo auf die Datenbank zugegriffen werden soll.
Dann ist der zweite Parameter der.
Wenn Sie sich also das „Dokument einfügen“ ansehen
, sehen Sie, dass der zweite Parameter das einzufügende Dokument ist.
Also, ich werde sagen: „Name. „
Ich werde hier nur ein JSON-Objekt oder ein JavaScript-Objekt konstruieren,
das beim Einfügen automatisch dem benachbarten Objekt zugeordnet wird.
Und der dritte Parameter, wie Sie sehen,
„db Dokumentensammlung und Rückruf.“
Der dritte Parameter ist also die Sammlung und die Sammlung ist
die Geschirr Sammlung und der letzte ist der Callback.
Der Rückruf erhält das Ergebnis erneut, wenn Sie sich erinnern.
Wenn Sie auf das Baby zurückblicken, das das Einfügedokument implementiert hat, hat
der Callback das Ergebnis als Parameter erhalten.
Also in diesem Callback werden wir diesen Ergebniswert hier behandeln.
Also, wenn der Ergebniswert hereinkommt, werden wir eine console.log machen.
Wir sagen einfügen Dokument
Backslash N und wir sagen Ergebnis OPS.
Die OPS gibt Ihnen die Anzahl der durchgeführten Einfügevorgänge an.
Dies ist also ein anderes Objekt, das sich auf dem
JavaScript-Objekt des Ergebnisses befindet,
das als Parameter zurückgegeben wird, und daher werde ich diesen Wert einfach ausdrucken.
Das wird uns ein paar Informationen darüber geben, was passiert ist.
Sobald dies abgeschlossen ist,
werde ich in dieser Callback-Funktion die nächste Datenbankoperation aufrufen.
Also sage ich dboper und finde dann die Dokumente.
Dann sage ich dbgerichte und der dritte Parameter ist docs,
was die Callback-Funktion ist.
Wenn ich die Dokumente erhalte, werde ich eine
console.log machen, die gefundene Dokumente sagt,
und wir werden die Dokumente einfach auf dem Bildschirm sperren.
Dies wird also die gefundenen Dokumente ausdrucken.
Beachten Sie, dass sich dieser Aufruf innerhalb
der Callback-Funktion befindet, die für den früheren Funktionsaufruf angewendet
wird, also möchte ich, dass Sie speziell bemerken.
Nun, wieder innerhalb dieses Funktionsaufrufs müssen sie es auf diese Weise tun, denn bis
dieser Callback aufgerufen wird, können wir die nächste Operation nicht ausführen.
Also, in dieser nächsten Operation werde ich das Dokument aktualisieren, das ich gerade eingefügt habe.
Also werde ich sagen, aktualisieren Sie das Dokument und ich sage Update Document DB,
und dann ist der nächste Parameter das Dokument,
und ich muss nicht das gesamte Dokument angeben, ich kann nur ein Feld angeben und
dann wird das Dokument finden, das zu diesem bestimmten Feld passt.
Was ich tun werde, ist der nächste Parameter ist das Update, das bereitgestellt werden muss.
Also, das Update ist, welches Feld ich aktualisieren möchte,
also werde ich
das Beschreibungsfeld aktualisieren, indem ich Aktualisierter Test sage,
und dann ist die vierte die Sammlung, die Dishes ist,
und die letzte ist die Callback-Funktion, die
die Dokumente als Rückgabewert oder
eher Ergebnis erhält des Aktualisierungsvorgangs, den wir gerade durchgeführt haben.
Dann innerhalb dieser Callback-Funktion
werde ich wieder eine console.log tun, die den
aktualisierten Dokumentrückslash N sagt. Das aktualisierte Dokument wird
in result.result für
diese Eigenschaft des Ergebnisobjekts zurückgegeben, das Tracking übergeben wird.
Beachten Sie hier wieder, wie die Aufrufe
in den Callback-Funktionen verschachtelt werden.
Ich möchte, dass Sie diese Struktur des Codes
speziell bemerken, weil das ist, worauf ich in der nächsten Übung zurückkommen werde.
Nachdem ich das getan
habe, werde ich die Dokumente finden,
also lassen Sie mich das einfach kopieren und dann werde ich den gleichen Code hier verwenden.
Also werde ich sagen, Dokumente finden.
Drinnen hier werde ich wieder sagen, gefunden aktualisiertes Dokument.
Dann schließlich, wenn ich damit fertig bin,
werde ich einfach db Drop Collection aufrufen.
Also werde ich diese Geschirr Sammlung löschen, so dass ich
meine Datenbank bereinigen werde, so dass ich
nichts mehr habe, weil ich für die nächste Übung
die Datenbank bereinigen und dann mit einer saubereren Datenbank beginnen möchte.
Also, ich werde
die Geschirr Sammlung reinigen und dann würde dies zu einem Rückruf führen.
Also hier drinnen werde ich eine console.log sagen,
Sammlung fallen gelassen, und dann werde ich nur das Ergebnis ausdrucken, das hereinkam.
Schließen Sie dann schließlich die Datenbank.
Beachten Sie, dass die Struktur des Codes,
DB Dokument einfügen und innerhalb der Callback-Funktion werde ich
die nächste Funktion aufrufen und innerhalb
des Callbacks aus, dass ich
die nächste Funktion und innerhalb der Callback nächste Funktion aufrufen werde und so weiter.
So sehen Sie hier einen verschachtelten Satz von Callbacks und
einen Baum strukturierten verschachtelten Satz von Rückrufen.
Das ist etwas, worauf du achten sollst.
Lassen Sie uns die Änderungen speichern und gehen und schauen Sie sich diese Version unserer Anwendung an.
Wenn Sie zum Terminal zurückkehren,
lassen Sie mich die Anwendung ausführen.
Also lassen Sie mich NPM start eingeben und wir werden dieses Ergebnis sehen.
Nun, aus diesem Ergebnis können Sie sehen, dass das Dokument
in die Sammlung eingefügt wird und das ist das Dokument, das gefunden wurde.
Im zweiten Schritt
finden wir das Dokument also, wenn wir das DB finden Dokument aufrufen,
also ist dies das Dokument, das aus meiner Sammlung abgerufen wird.
Dann bitte ich es, das Dokument damit zu aktualisieren,
und dann werden Sie feststellen, dass es aktualisiertes Dokument sagt und dann
hier druckt es das Ergebnis oder OPS und es sagt, N ist gleich
einer Zahl, die als eins geändert wurde und es war in Ordnung.
Dann druckt es das aktualisierte Dokument aus,
wir finden das aktualisierte Dokument hier und das ist, was hier gedruckt wird,
und beachten Sie insbesondere, dass die Beschreibung aktualisiert wurde.
Dann schließlich hat es die Sammlung fallen gelassen.
So sehen wir, wie diese Anwendung läuft und in der Lage ist,
das Knotenmodul zu nutzen, das wir implementiert und dann verschiedene Datenbankoperationen durchgeführt haben.
Damit schließen wir diese Übung ab.
In dieser Übung habe ich Ihnen gezeigt, wie Sie mit
Ihrem MongoDB-Server von Ihrer Knotenanwendung aus interagieren würden.
Wir haben hier unser eigenes Knotenmodul implementiert und es dann
innerhalb unserer Knotenanwendung verwendet, indem wir
bestimmte Datenbankoperationen in dieses Knotenmodul kapseln.
Dies ist ein guter Zeitpunkt für Sie, ein Git-Commit mit
dem Nachrichtenknoten MongoDB Beispiel Teil zwei zu machen.