In dieser Übung werden wir weiter an
dem Knoten Mongoose Server arbeiten, den wir in der vorherigen Übung entwickelt haben.
Wir werden eine weitere Variante davon machen.
Darüber hinaus werden wir uns auch ansehen, wie Mongoose Unterdokumente unterstützt,
und dies ermöglicht es uns, ein Dokument in
einem Dokument zu speichern, um zusätzliche Informationen zu speichern.
Schauen wir uns das in der nächsten Übung an. Wenn
wir mit dem Beispiel fortfahren, an dem wir gearbeitet haben,
sehen wir jetzt in der Datei index.js eine neue Möglichkeit, ein Gericht zu erstellen und es in unsere Anwendung hinzuzufügen.
Also, früher hatten wir var NewDish und Gerichte getan und definieren das Gericht.
Nun, in diesem Fall werden wir eine neue Methode namens Gerichte erstellen verwenden, die,
als Parameter, die NewDish zu erstellen und dann speichert es in unserer Anwendung.
Also, anstatt dieses NewDish speichern,
können wir einfach entfernen, dass und direkt mit den Gerichten umgehen Methode hier erstellen.
Also, die Gerichte erstellen Methode wird als Parameter
ein neues Dokument, das in unserer Datenbank gespeichert werden muss,
und dann erstellt und fügt das Dokument in die Datenbank.
Danach können wir mit dem Rest der Übung fortfahren.
Diese geringfügige Änderung zeigt
, dass dieselbe Anwendung genauso läuft wie zuvor.
Also, mit dieser Änderung,
lassen Sie mich einfach die Einrückung
hier ändern, so dass die Verkettung der dann Methoden sehr klar ist.
Also, wir machen zuerst ein Geschirr erstellen, das ein Versprechen zurückgeben wird,
und dann wechseln wir zum dann und dann werden wir
die restlichen Schritte auf dem geschaffenen Gericht ausführen.
Lassen Sie uns die Änderungen speichern und dann gehen und werfen Sie einen Blick auf diese Version unseres Servers. Wenn wir
wieder zum Terminal gehen,
sehen wir, dass es genau das gleiche wie die vorherige Variante des Servers erstellt.
Also, wir erstellen hier ein neues Gericht und fügen es dann in
die Datenbank ein und danach
holen wir dieses Gericht und drucken dann auf dem Bildschirm aus.
Mit dieser Änderung ist dies ein guter Zeitpunkt für uns,
ein Git-Commit mit der Nachricht Mongoose Teil zwei zu machen.
Also, lassen Sie uns den Git-Status überprüfen und dann die Datei zum Repository hinzufügen
und dann ein Git-Commit mit der Nachricht Mongoose Teil zwei machen.
Fortsetzung der Übung
werden wir im nächsten Schritt ein Unterdokument
zum Dokument hinzufügen und sehen, wie Unterdokumente in unserer Datenbank gespeichert werden können.
Also, wenn
ich zur Datei dishes.js gehe, werde ich ein anderes Schema in meine dishes.js Datei
als Kommentar Schema hinzufügen und
dann als neues Schema definieren.
In diesem Kommentarschema,
wie Sie bereits erwartet hätten,
werden wir dies verwenden, um Kommentare über das Gericht zu speichern.
Also, die Kommentare enthalten ein Bewertungsfeld,
das vom Typ Nummer ist,
und sein minimaler Wert ist eins,
Maximalwert ist fünf und erforderlich ist wahr.
Sie können also sehen, dass Sie, wenn Sie ein Feld mit der Typnummer verwenden,
die Grenzen dafür angeben können, wenn Sie dies wünschen.
Dann ist das nächste Feld ein Kommentarfeld, das vom Typ String sein würde.
Also, dies speichert eine Nachricht und dann erforderlich
ist wahr und dann werden wir auch ein anderes Feld namens Autor hinzufügen,
das vom Typ String ist und erforderlich ist wahr ist.
Wir werden auch das Zeitstempelfeld dafür hinzufügen
und das auf true setzen.
Also, für jeden Kommentar, der hinzugefügt
wird, speichern wir auch den entsprechenden Zeitstempel.
Nun, da wir ein Kommentarschema deklariert haben,
können wir dann weitergehen und das Dish Schema ändern, um Kommentare speichern zu können.
Also, innerhalb des Schemas Gerichte,
können wir in Kommentaren hinzufügen,
die ein Array des Typkommentarschemas ist,
was bedeutet, dass jedes Gericht Objekt,
Gericht Dokument mehrere Kommentare in einem Array innerhalb des Dish Dokument gespeichert haben kann.
Also, dies ist die Kommentardokumente werden Unterdokumente in einem Gericht Dokument.
Also, wir speichern alle Kommentare über das Gericht in
der Schale selbst als eine Reihe von Kommentardokumenten.
Dies ist also die Verwendung des Unterdokuments in Mongoose.
Danach gehen wir zur Datei index.js und ändern Sie dann unsere Datei index.js.
Hier kreieren sie das Gericht wie zuvor.
Dann, nachdem wir das Gericht erstellt haben,
trösten wir das Gericht.
Danach werden wir das Gericht aktualisieren.
Also, wir werden sagen, Gerichte finden nach ID und aktualisieren.
Also werden wir das Gericht ändern, das wir gerade im vorherigen Schritt eingefügt haben.
Also, wir sagen: „Finden Sie nach ID und aktualisieren Sie.“
Und wir werden liefern.
In diesem nimmt zwei Parameter,
der erste Parameter ist das Gericht.
Nun, dieses Gericht. _id bezieht sich natürlich auf dieses Gericht, das wir gerade eingefügt haben,
und dann werden wir das gleiche Gericht im nächsten Schritt ändern.
Also sagen wir: „Dish. _ID.“ Und dann,
in Klammern, geben wir $set, Beschreibung,
aktualisierter Test und new true.
Also, das, wir modifizieren das Gericht, das wir
gerade eingefügt haben, indem wir seine Beschreibung dort aktualisieren.
Nun, das muss innen eingeschlossen werden.
Diese zweite Flagge, die wir hier liefern,
neue Doppelpunkt gleich wahr,
bedeutet, dass, sobald die Aktualisierung des Gerichts abgeschlossen ist,
dann wird dies das Gericht,
aktualisierte Gericht zurück zu uns.
Also, das ist der Grund für die Verwendung dieser Flagge hier, sagen wir, new true.
Also, dieses Gericht wird im nächsten Schritt zurückgegeben.
Und so werden wir das Gericht nehmen und dann das Gericht ausdrucken.
Also, im nächsten Schritt,
werden wir das ändern und sagen: „Dies, dann Gericht.“
Und dann machen wir ein Konsolenprotokoll.
Danach werden wir einen Kommentar in das Gericht einfügen.
Also, wir werden sagen: „Schüssel.Kommentare.Push.“
Daran erinnern, dass die Kommentare ein Feld in der Schale sind. Wenn wir
also auf das Schema zurückgehen,
sehen wir, dass diese Kommentare ein Array des CommentSchema-Typs sind.
Also, was bedeutet, dass wir ein Element in dieses Array schieben können.
Also, wenn wir hierher zurückgehen
, sagen wir: „Dish Comments Push“.
Und dann werden wir hier ein Kommentardokument in die Schüssel schieben.
Also, ich werde sagen: „Dish Kommentare drücken.“
Und geben Sie hier die Felder an.
Also sagen wir: „Bewertung fünf, Kommentar und Autor.“
Und so wird dies diesen Kommentar in das Kommentarfeld dieses speziellen Gerichts schieben.
Also, jetzt, da wir das Gericht modifiziert haben,
ist der nächste Schritt, den wir tun werden, dass
ich das abschließe und dann das hineinfüge, dann da.
Ich komme zurück und repariere das in kurzer Zeit.
Also, jetzt, wo wir das Gericht modifiziert haben,
müssen wir das Gericht retten.
Also sagen wir: „Tresor zurückgeben.“
In diesem Schritt
fügen wir einen Kommentar in das Gericht ein, das Gericht,
das wir gerade erstellt und aktualisiert haben,
und dann speichern wir
diesen Kommentar; und dann wird das Gericht zurückgeben.
Und wenn das Gericht im nächsten Rückruf zurückgegeben wird,
werde ich dann sagen: „Konsolenprotokoll Gericht.“
Und dann, danach,
werden wir sagen: „Zurück.“
Also, damit haben wir unsere index.js Datei geändert.
Lassen Sie uns die Änderungen speichern und schauen Sie sich diese Anwendung an.
Gehen wir zum Terminal,
lassen Sie uns npm start ausführen und dann den resultierenden Wert hier sehen.
Also, wenn wir zurückgehen, sehen wir, dass
wir im ersten Schritt dieses Gericht hier mit dem Namen und der Beschreibung erstellt haben, wie wir zuvor gegeben haben.
Und dann, sobald das Gericht erstellt wurde
,
haben wir im zweiten Schritt das Gericht aktualisiert und dann die aktualisierte Version des Gerichts ausgedruckt.
So wird die aktualisierte Version des Gerichts direkt dort ausgedruckt.
Und Sie können sehen, dass die Beschreibung aus dem vorherigen Fall aktualisiert wurde,
aber die ID bleibt genau die gleiche wie das Gericht, das wir zuvor erstellt haben.
Und das Kommentarfeld,
wie Sie hier sehen können,
ist ein leeres Array und das geräucherte.
Im dritten Schritt schieben wir den Kommentar in unser Gericht hier;
und dann
wurde dieser besondere Kommentar, den wir hinzugefügt haben, in dieses Kommentarfeld hinzugefügt.
So können Sie sehen, dass dieser Kommentar hier beigefügt wird,
und dies ist das aktualisierte Gericht, das jetzt auf den Bildschirm gedruckt wurde.
So können Sie sehen, dass wir mehrere Schritte nacheinander mit unserem Gericht gemacht haben.
Wir haben zuerst das Gericht erstellt,
dann haben wir das Gericht aktualisiert,
dann haben wir einen Kommentar in die Schüssel eingefügt,
die ein Unterdokument innerhalb des Geschirrdokuments ist;
und dann haben wir das Ergebnis ausgedruckt.
Damit schließen wir diese Übung ab.
In dieser Übung haben wir gesehen, wie wir
zuerst ein Gericht erstellen können, indem Sie Gerichte erstellen,
dann sahen wir die Verwendung von Unterdokumenten: Dort
haben wir ein Schema innerhalb der
Datei dishes.js definiert und dann das Kommentarschema verwenden, das wir
definiert haben und dann das Feld im Schema Gerichte als -Array des CommentSchema-Typs.
Und dann, in der Datei index.js,
konnten wir ein Gericht erstellen,
das Gericht aktualisieren und auch
ein Kommentardokument in die Schüssel schieben und dann die Änderungen hier speichern.
Damit schließen wir diese Übung ab.
Dies ist ein guter Zeitpunkt für Sie, einen Git Kermit mit mit der Nachricht „Mungo Teil drei“ zu machen.