1
00:00:03,950 --> 00:00:09,370
In dieser Übung werden wir mit der vorherigen Übung fortfahren, in der wir

2
00:00:09,370 --> 00:00:14,650
die Interaktion zwischen der Knotenanwendung und dem MongoDB-Server entwickelt haben.

3
00:00:14,650 --> 00:00:18,120
In dieser Übung werde ich einige der

4
00:00:18,120 --> 00:00:21,750
Datenbankoperationen in ein eigenes Knotenmodul,

5
00:00:21,750 --> 00:00:23,540
ein dateibasiertes Knotenmodul, kapseln

6
00:00:23,540 --> 00:00:29,345
und es dann innerhalb meiner Knotenanwendung verwenden, um mit dem Server zu interagieren.

7
00:00:29,345 --> 00:00:31,940
Gleichzeitig führen wir mehrere Operationen auf

8
00:00:31,940 --> 00:00:35,630
dem Server durch, um zu demonstrieren, dass wir

9
00:00:35,630 --> 00:00:43,040
mit dem Server interagieren können, indem wir unsere Knotenanwendung und den Knoten MongoDB-Treiber verwenden.

10
00:00:43,040 --> 00:00:47,605
Um zu beginnen, gehen wir zu unserem Projekt

11
00:00:47,605 --> 00:00:53,975
und erstellen Sie dann eine neue Datei namens operations.js.

12
00:00:53,975 --> 00:00:57,720
Diese Datei kapselt alle Datenbankoperationen,

13
00:00:57,720 --> 00:01:00,705
die vier Operationen, die ich ausführen werde einfügen,

14
00:01:00,705 --> 00:01:05,855
finden, entfernen und aktualisieren Sie ein Dokument in meiner Datenbank.

15
00:01:05,855 --> 00:01:09,980
Nun wird dies als dateibasiertes Knotenmodul organisiert,

16
00:01:09,980 --> 00:01:15,070
das ich dann in meiner Knotenanwendung verwenden werde, um auf den Server zuzugreifen.

17
00:01:15,070 --> 00:01:16,330
Um loszulegen, lassen Sie

18
00:01:16,330 --> 00:01:25,780
mich zuerst Assert

19
00:01:25,780 --> 00:01:27,565
in diesem Knotenmodul benötigen,

20
00:01:27,565 --> 00:01:30,225
und da dies ein Knotenmodul ist,

21
00:01:30,225 --> 00:01:35,055
werden wir mehrere Methoden aus dem Knotenmodul exportieren.

22
00:01:35,055 --> 00:01:41,705
Die erste Methode wäre das Einfügen Dokument offensichtlich, wie Sie es erwarten würden,

23
00:01:41,705 --> 00:01:44,520
und dies wird vier Parameter DB nehmen,

24
00:01:44,520 --> 00:01:49,555
die MongoDB, Datenbankverbindung innerhalb meiner Knotenanwendung,

25
00:01:49,555 --> 00:01:54,240
die ich innerhalb der Knotenanwendung erhalten werde.

26
00:01:54,240 --> 00:01:57,785
Dann ist das zweite das Dokument, das ich einfügen möchte.

27
00:01:57,785 --> 00:02:02,800
Der dritte Parameter ist die Sammlung, in die ich das Dokument einfügen möchte.

28
00:02:02,800 --> 00:02:05,675
Die letzte ist eine Callback-Funktion,

29
00:02:05,675 --> 00:02:10,425
die zurückgerufen wird, sobald diese Operation abgeschlossen ist.

30
00:02:10,425 --> 00:02:14,800
Dann schließen wir die Funktion hier,

31
00:02:14,800 --> 00:02:20,100
und dies kapselt im Wesentlichen die Einfügedokumentmethode hier.

32
00:02:20,100 --> 00:02:27,415
Dies ist also eine Funktion, die von diesem Knotenmodul hier exportiert wird.

33
00:02:27,415 --> 00:02:34,250
Nun werde ich hier auch ein paar weitere Methoden einbinden.

34
00:02:34,250 --> 00:02:42,870
Der zweite wäre Finddocuments.

35
00:02:42,870 --> 00:02:46,025
Nicht nur ein, sondern mehrere Dokumente.

36
00:02:46,025 --> 00:02:54,390
Dies würde ich die Sammlung durchsuchen und alle Dokumente finden, die in der Sammlung sind.

37
00:02:54,390 --> 00:02:58,130
Deshalb nehme ich nur die Datenbank

38
00:02:58,130 --> 00:03:02,090
und die Sammlung als die beiden Parameter zusammen mit dem Callback.

39
00:03:02,090 --> 00:03:11,550
Die dritte Funktion, die ich von hier aus implementieren werde, ist das removedocument.

40
00:03:12,290 --> 00:03:15,590
Dies unterstützt den Löschvorgang,

41
00:03:15,590 --> 00:03:19,855
und so nimmt der Name des Dokuments die Datenbank, das Dokument,

42
00:03:19,855 --> 00:03:23,775
die Sammlung und den Rückruf als die vier Parameter,

43
00:03:23,775 --> 00:03:30,595
und wir rufen den Callback auf, wenn der Vorgang abgeschlossen ist.

44
00:03:30,595 --> 00:03:34,445
Die letzte ist natürlich, das Dokument zu aktualisieren.

45
00:03:34,445 --> 00:03:38,120
Natürlich müssen Sie es nicht unbedingt so machen.

46
00:03:38,120 --> 00:03:42,830
Ich hatte nur das Gefühl, dass dies eine andere Möglichkeit wäre, zu veranschaulichen, wie Sie

47
00:03:42,830 --> 00:03:49,110
diese Funktionen in ein eigenes Knotenmodul einkapseln können.

48
00:03:49,110 --> 00:03:55,395
Dies ist nur die Reorganisation des Codes auf eine Weise, die einfacher zu verwenden ist.

49
00:03:55,395 --> 00:03:57,205
Also, für die Exporte,

50
00:03:57,205 --> 00:04:00,070
für das Update-Dokument braucht es die DB,

51
00:04:00,070 --> 00:04:03,750
eine Möglichkeit, das Dokument als zweiten Parameter zu identifizieren.

52
00:04:03,750 --> 00:04:06,205
Der dritte Parameter ist die Aktualisierung,

53
00:04:06,205 --> 00:04:08,750
und der vierte Parameter ist die Sammlung, in der

54
00:04:08,750 --> 00:04:11,505
dieses Dokument vorhanden ist, und der Rückruf.

55
00:04:11,505 --> 00:04:18,160
Also, vier Funktionen, die von der Datei operations.js exportiert werden.

56
00:04:18,160 --> 00:04:20,380
Nun, innerhalb dieser Funktionen,

57
00:04:20,380 --> 00:04:21,735
lassen Sie uns eins nach dem anderen implementieren.

58
00:04:21,735 --> 00:04:23,420
Im Einfügedokument

59
00:04:23,420 --> 00:04:27,680
ist das erste, was ich tun werde,

60
00:04:27,680 --> 00:04:36,000
const collection zu sagen und es wird DB Sammlung sagen,

61
00:04:38,930 --> 00:04:44,710
und der Parameter ist die Sammlung.

62
00:04:45,350 --> 00:04:50,190
Also, wir werden dort nach der Sammlung suchen.

63
00:04:50,190 --> 00:04:54,640
Nun, dies muss in allen vier Methoden durchgeführt werden.

64
00:04:54,640 --> 00:04:59,990
Also, ich werde gehen und diesen Code in alle vier Methoden hier einfügen,

65
00:05:01,140 --> 00:05:05,390
weil das eine Funktion ist, die ich in allen von ihnen brauche.

66
00:05:05,390 --> 00:05:11,680
Also, sobald ich die Sammlung erhalte,

67
00:05:11,680 --> 00:05:13,895
kann ich, wie Sie sich aus der vorherigen Übung erinnern, Operationen an der Sammlung durchführen.

68
00:05:13,895 --> 00:05:19,160
Also, ich sage Sammlung, Einfügen,

69
00:05:21,300 --> 00:05:27,610
und dies nimmt als ersten Parameter das einzufügende Dokument,

70
00:05:27,610 --> 00:05:35,695
und der zweite Parameter ist der Callback mit dem Fehler und diesem Ergebnis.

71
00:05:35,695 --> 00:05:40,990
Also, jetzt, wenn dieses Dokument

72
00:05:40,990 --> 00:05:46,780
durch Aufruf der Insert-Methode für die Datenbanksammlung eingefügt wird,

73
00:05:46,780 --> 00:05:49,180
lassen Sie mich die Insert-Methode erinnern,

74
00:05:49,180 --> 00:05:52,090
wird vom MongoDB-Treiber unterstützt.

75
00:05:52,090 --> 00:05:53,980
Also, das ist die Methode, die wir hier verwenden,

76
00:05:53,980 --> 00:05:56,420
oder das ist die Funktion, die wir hier verwenden.

77
00:05:56,420 --> 00:06:05,060
Nun, das erste, was ich nach diesem überprüfen werde, assertequal irr, null.

78
00:06:05,060 --> 00:06:09,185
Also möchte ich sicherstellen, dass ich keinen Fehler habe.

79
00:06:09,185 --> 00:06:11,225
Also möchte ich sicherstellen, dass der Fehler null ist.

80
00:06:11,225 --> 00:06:12,470
Wenn es nicht null ist,

81
00:06:12,470 --> 00:06:15,930
wird dies die Informationen ausdrucken und dann die Anwendung beenden.

82
00:06:15,930 --> 00:06:19,760
In diesem Moment denke ich, dass dies in Ordnung ist, um damit umzugehen, dass

83
00:06:19,760 --> 00:06:24,680
wir später sehen werden, wie wir eine globale Methode haben können, alle Fehler zu behandeln, wenn wir

84
00:06:24,680 --> 00:06:34,390
in der nächsten Lektion eine andere Möglichkeit des Zugriffs auf die MongoDB-Datenbank implementieren.

85
00:06:34,390 --> 00:06:36,640
Nun, nachdem ich das getan

86
00:06:36,640 --> 00:06:38,050
habe, werde ich implementieren,

87
00:06:38,050 --> 00:06:40,075
werde ich diese Informationen einfach protokollieren.

88
00:06:40,075 --> 00:06:48,570
Also werde ich sagen, Konsolenprotokoll und fügen Sie es ein.

89
00:06:48,570 --> 00:06:55,375
Also, diese Information wird hier auf den Bildschirm ausgedruckt, eingefügt.

90
00:06:55,375 --> 00:07:00,440
Erinnern Sie sich an die Semikolons und alles, was

91
00:07:00,440 --> 00:07:05,120
wichtig ist, vergessen Sie sie nicht, wenn Sie Ihren Code eingeben.

92
00:07:05,120 --> 00:07:07,930
Also, ich werde sagen, eingefügt Ergebnis.

93
00:07:07,930 --> 00:07:12,165
Dieses Ergebnisobjekt, das zurückgegeben

94
00:07:12,165 --> 00:07:15,785
wird, hat eine Eigenschaft namens Ergebniseigenschaft,

95
00:07:15,785 --> 00:07:20,270
und diese Eigenschaft enthält einen Wert.

96
00:07:20,270 --> 00:07:23,600
Diese Ergebniseigenschaft ist auch ein JavaScript-Objekt,

97
00:07:23,600 --> 00:07:31,395
und dies wird eine Eigenschaft n enthalten, die uns mitteilt, wie viele Dokumente eingefügt wurden.

98
00:07:31,395 --> 00:07:36,875
Das sind also die Informationen, die ich hier ausdrucken

99
00:07:36,875 --> 00:07:39,540
werde, und dann gehen wir zur nächsten Zeile und

100
00:07:39,540 --> 00:07:50,750
sagen „Dokumente in die Sammlung“.

101
00:07:53,070 --> 00:08:02,040
Nun, dies ist nur eine Möglichkeit, den Benutzer zu informieren, dass diese Operation korrekt stattgefunden hat,

102
00:08:02,040 --> 00:08:10,135
und dann werden sie dieses Ergebnis an unsere aufrufende Funktion übergeben.

103
00:08:10,135 --> 00:08:15,330
Also, wir rufen den Callback auf und dann wird das Ergebnis der Parameter für den Callback sein.

104
00:08:15,330 --> 00:08:21,595
Wenn wir also die Verwendung dieser Funktion in unserer Datei index.js implementieren,

105
00:08:21,595 --> 00:08:23,930
werden wir dort den Rückruf bereitstellen, der

106
00:08:23,930 --> 00:08:26,880
das Ergebnis als eingehender Parameter erhält.

107
00:08:26,880 --> 00:08:30,670
Dies ist also für das „InsertDocument“.

108
00:08:30,670 --> 00:08:33,010
Nun, für das „FindDocument

109
00:08:33,010 --> 00:08:36,750
“, was ich tun werde, ist zu sagen,

110
00:08:37,010 --> 00:08:41,640
„coll.find“ und ich werde alle Dokumente finden.

111
00:08:41,640 --> 00:08:44,810
Also, deshalb werde ich hier ein leeres JavaScript-Objekt geben,

112
00:08:44,810 --> 00:08:51,040
das mit allen Dokumenten in der Sammlung übereinstimmt und dann werde ich sagen,

113
00:08:51,040 --> 00:09:01,820
„ToArray“ und dies wird als Parameter eine Callback-Funktion nehmen,

114
00:09:02,220 --> 00:09:06,505
und innerhalb dieser Callback-Funktion

115
00:09:06,505 --> 00:09:11,710
werde ich natürlich behaupten, dass dies nicht null ist,

116
00:09:11,710 --> 00:09:20,590
und dann werden wir sagen, „Callback docs.“

117
00:09:20,590 --> 00:09:27,440
Wir werden die abgerufenen Dokumente einfach an die aufrufende Funktion zurückgeben.

118
00:09:28,200 --> 00:09:37,750
Nun, für das „RemoveDocument“, werde ich sagen, „Sammlung DeleteOne.“

119
00:09:37,750 --> 00:09:40,270
Also werde ich versuchen, das erste Dokument zu finden, das

120
00:09:40,270 --> 00:09:45,130
mit dem übereinstimmt, was wir angegeben haben, und dann löschen.

121
00:09:45,130 --> 00:09:47,070
Und dann wird dies wiederum

122
00:09:47,070 --> 00:09:50,380
eine Callback-Funktion als zweiter Parameter nehmen,

123
00:09:50,380 --> 00:09:52,685
und innerhalb dieser Callback-Funktion

124
00:09:52,685 --> 00:09:58,160
überprüfe ich zuerst, um sicherzustellen, dass der Fehler nicht null ist.

125
00:09:58,160 --> 00:10:01,820
Und dann werden wir sagen,

126
00:10:02,130 --> 00:10:20,890
„Konsolenprotokoll entfernt das Dokument Komma Dokument.“

127
00:10:20,890 --> 00:10:24,840
Wir haben das Komma hier verwendet, weil dies ein JavaScript-Objekt ist.

128
00:10:24,840 --> 00:10:26,890
Wenn Sie also Konsolenprotokoll wie folgt angeben,

129
00:10:26,890 --> 00:10:30,360
wird das Dokument ausgedruckt und dann werden wir dieses

130
00:10:30,360 --> 00:10:36,705
Ergebnis durch die Callback-Funktion zurückgeben.

131
00:10:36,705 --> 00:10:47,550
Und dann schließlich, für das Update werden wir coll.UpdateOne.

132
00:10:47,670 --> 00:10:52,255
Dies ist eine Methode, die der MongoDB-Treiber unterstützt.

133
00:10:52,255 --> 00:10:56,560
Also, ich werde sagen, „update.Ein Dokument

134
00:10:56,560 --> 00:11:01,480
“, und der zweite Parameter ist, wo wir

135
00:11:01,480 --> 00:11:06,960
in den Feldern übergeben, die aktualisiert werden müssen.

136
00:11:06,960 --> 00:11:08,915
Und so wie es gemacht wird

137
00:11:08,915 --> 00:11:12,810
, sagen wir: „Dollarsatz Doppelpunkt aktualisieren“.

138
00:11:12,810 --> 00:11:16,100
Also, dies wird die Update-Informationen, die

139
00:11:16,100 --> 00:11:19,120
ich schicke, nehmen und dann in das update.one übergeben.

140
00:11:19,120 --> 00:11:21,620
Das erste ist das Dokument, das aktualisiert werden muss.

141
00:11:21,620 --> 00:11:25,425
Die zweite ist, welche Felder des Dokuments hier aktualisiert werden müssen.

142
00:11:25,425 --> 00:11:28,660
Und der dritte Parameter ist null,

143
00:11:28,770 --> 00:11:36,305
und dieser letzte Parameter ist eine Callback-Funktion,

144
00:11:36,305 --> 00:11:45,660
die uns offensichtlich das Ergebnis der Operation gibt.

145
00:11:45,660 --> 00:11:51,125
Also, zuerst werde ich überprüfen, um sicherzustellen, dass der Fehler nicht null ist.

146
00:11:51,125 --> 00:11:59,535
Dann werde ich eine „Konsolenprotokoll aktualisiert das Dokument mit.“

147
00:11:59,535 --> 00:12:03,195
Nun wieder, die Konsolenprotokolle sind rein für uns, um

148
00:12:03,195 --> 00:12:07,920
sicherzustellen, dass der Code tut, was er tut.

149
00:12:07,920 --> 00:12:09,690
Es hilft in keiner Weise.

150
00:12:09,690 --> 00:12:11,995
Dies ist nur zu unseren eigenen Informationen.

151
00:12:11,995 --> 00:12:15,070
In einem Produktionsserver

152
00:12:15,070 --> 00:12:18,570
würden Sie vielleicht keine Konsolenprotokolle haben.

153
00:12:18,570 --> 00:12:24,220
Sie können sie deaktivieren. Also, das war's.

154
00:12:24,220 --> 00:12:32,370
Also vier Methoden, die in diesem speziellen dateibasierten Knotenmodul unterstützt werden, einfügen,

155
00:12:32,370 --> 00:12:35,040
finden, entfernen und aktualisieren.

156
00:12:35,040 --> 00:12:38,490
Also, jetzt, da wir dieses dateibasierte Knotenmodul implementiert haben,

157
00:12:38,490 --> 00:12:41,185
gehen wir zur Datei index.js,

158
00:12:41,185 --> 00:12:45,985
und dann, um dieses dateibasierte Knotenmodul

159
00:12:45,985 --> 00:12:48,010
zu verwenden, muss ich dies hier benötigen.

160
00:12:48,010 --> 00:12:53,969
Also, ich werde sagen, „const dboper erfordern.“

161
00:12:53,969 --> 00:13:00,155
Da dies ein dateibasiertes Knotenmodul ist, erhalten Sie den vollständigen Pfad zum Knotenmodul,

162
00:13:00,155 --> 00:13:03,865
und was in diesem Fall passiert. /operations

163
00:13:03,865 --> 00:13:09,760
, weil es sich im selben Ordner wie meine Datei index.js befindet.

164
00:13:09,760 --> 00:13:12,400
Nun, sobald wir dies getan haben,

165
00:13:12,400 --> 00:13:19,570
dann genau hier, diese Funktion,

166
00:13:19,570 --> 00:13:24,355
dieser Code, den wir getan haben, um auf die Datenbank zuzugreifen jetzt einfügen,

167
00:13:24,355 --> 00:13:32,430
werden wir den DBoper verwenden, den wir gerade implementiert haben, um auf diese Datenbank zuzugreifen.

168
00:13:32,430 --> 00:13:36,280
Also, wir werden sagen, „dboper insert document

169
00:13:36,280 --> 00:13:40,345
“, und dieses „insert document“ nimmt die db als ersten Parameter.

170
00:13:40,345 --> 00:13:45,015
Die db hier, ist diese db, die kam, wenn wir MongoClient connect aufrufen.

171
00:13:45,015 --> 00:13:48,010
So dass db übergeben wird, so dass

172
00:13:48,010 --> 00:13:53,805
mein Betriebsknotenmodul weiß, wo auf die Datenbank zugegriffen werden soll.

173
00:13:53,805 --> 00:13:59,325
Dann ist der zweite Parameter der.

174
00:13:59,325 --> 00:14:03,950
Wenn Sie sich also das „Dokument einfügen“ ansehen

175
00:14:03,950 --> 00:14:08,055
, sehen Sie, dass der zweite Parameter das einzufügende Dokument ist.

176
00:14:08,055 --> 00:14:10,850
Also, ich werde sagen: „Name. „

177
00:14:11,640 --> 00:14:21,680
Ich werde hier nur ein JSON-Objekt oder ein JavaScript-Objekt konstruieren,

178
00:14:21,680 --> 00:14:27,315
das beim Einfügen automatisch dem benachbarten Objekt zugeordnet wird.

179
00:14:27,315 --> 00:14:30,135
Und der dritte Parameter, wie Sie sehen,

180
00:14:30,135 --> 00:14:32,790
„db Dokumentensammlung und Rückruf.“

181
00:14:32,790 --> 00:14:36,690
Der dritte Parameter ist also die Sammlung und die Sammlung ist

182
00:14:36,690 --> 00:14:42,855
die Geschirr Sammlung und der letzte ist der Callback.

183
00:14:42,855 --> 00:14:48,605
Der Rückruf erhält das Ergebnis erneut, wenn Sie sich erinnern.

184
00:14:48,605 --> 00:14:52,710
Wenn Sie auf das Baby zurückblicken, das das Einfügedokument implementiert hat, hat

185
00:14:52,710 --> 00:14:55,245
der Callback das Ergebnis als Parameter erhalten.

186
00:14:55,245 --> 00:15:00,305
Also in diesem Callback werden wir diesen Ergebniswert hier behandeln.

187
00:15:00,305 --> 00:15:07,000
Also, wenn der Ergebniswert hereinkommt, werden wir eine console.log machen.

188
00:15:07,390 --> 00:15:12,750
Wir sagen einfügen Dokument

189
00:15:13,240 --> 00:15:20,565
Backslash N und wir sagen Ergebnis OPS.

190
00:15:20,565 --> 00:15:24,760
Die OPS gibt Ihnen die Anzahl der durchgeführten Einfügevorgänge an.

191
00:15:24,760 --> 00:15:28,680
Dies ist also ein anderes Objekt, das sich auf dem

192
00:15:28,680 --> 00:15:31,790
JavaScript-Objekt des Ergebnisses befindet,

193
00:15:31,790 --> 00:15:34,650
das als Parameter zurückgegeben wird, und daher werde ich diesen Wert einfach ausdrucken.

194
00:15:34,650 --> 00:15:38,260
Das wird uns ein paar Informationen darüber geben, was passiert ist.

195
00:15:38,260 --> 00:15:40,610
Sobald dies abgeschlossen ist,

196
00:15:40,610 --> 00:15:45,880
werde ich in dieser Callback-Funktion die nächste Datenbankoperation aufrufen.

197
00:15:45,880 --> 00:15:50,730
Also sage ich dboper und finde dann die Dokumente.

198
00:15:50,730 --> 00:16:00,260
Dann sage ich dbgerichte und der dritte Parameter ist docs,

199
00:16:00,260 --> 00:16:03,090
was die Callback-Funktion ist.

200
00:16:03,090 --> 00:16:06,100
Wenn ich die Dokumente erhalte, werde ich eine

201
00:16:06,100 --> 00:16:15,170
console.log machen, die gefundene Dokumente sagt,

202
00:16:16,170 --> 00:16:22,140
und wir werden die Dokumente einfach auf dem Bildschirm sperren.

203
00:16:22,140 --> 00:16:25,075
Dies wird also die gefundenen Dokumente ausdrucken.

204
00:16:25,075 --> 00:16:28,470
Beachten Sie, dass sich dieser Aufruf innerhalb

205
00:16:28,470 --> 00:16:37,480
der Callback-Funktion befindet, die für den früheren Funktionsaufruf angewendet

206
00:16:37,480 --> 00:16:41,225
wird, also möchte ich, dass Sie speziell bemerken.

207
00:16:41,225 --> 00:16:46,290
Nun, wieder innerhalb dieses Funktionsaufrufs müssen sie es auf diese Weise tun, denn bis

208
00:16:46,290 --> 00:16:52,185
dieser Callback aufgerufen wird, können wir die nächste Operation nicht ausführen.

209
00:16:52,185 --> 00:16:58,855
Also, in dieser nächsten Operation werde ich das Dokument aktualisieren, das ich gerade eingefügt habe.

210
00:16:58,855 --> 00:17:03,990
Also werde ich sagen, aktualisieren Sie das Dokument und ich sage Update Document DB,

211
00:17:03,990 --> 00:17:07,880
und dann ist der nächste Parameter das Dokument,

212
00:17:07,880 --> 00:17:11,800
und ich muss nicht das gesamte Dokument angeben, ich kann nur ein Feld angeben und

213
00:17:11,800 --> 00:17:20,740
dann wird das Dokument finden, das zu diesem bestimmten Feld passt.

214
00:17:21,960 --> 00:17:27,690
Was ich tun werde, ist der nächste Parameter ist das Update, das bereitgestellt werden muss.

215
00:17:27,690 --> 00:17:30,770
Also, das Update ist, welches Feld ich aktualisieren möchte,

216
00:17:30,770 --> 00:17:35,350
also werde ich

217
00:17:35,350 --> 00:17:42,050
das Beschreibungsfeld aktualisieren, indem ich Aktualisierter Test sage,

218
00:17:43,030 --> 00:17:48,475
und dann ist die vierte die Sammlung, die Dishes ist,

219
00:17:48,475 --> 00:17:53,820
und die letzte ist die Callback-Funktion, die

220
00:17:53,820 --> 00:18:01,110
die Dokumente als Rückgabewert oder

221
00:18:01,110 --> 00:18:08,705
eher Ergebnis erhält des Aktualisierungsvorgangs, den wir gerade durchgeführt haben.

222
00:18:08,705 --> 00:18:11,890
Dann innerhalb dieser Callback-Funktion

223
00:18:11,890 --> 00:18:20,845
werde ich wieder eine console.log tun, die den

224
00:18:20,845 --> 00:18:31,050
aktualisierten Dokumentrückslash N sagt. Das aktualisierte Dokument wird

225
00:18:31,050 --> 00:18:38,125
in result.result für

226
00:18:38,125 --> 00:18:43,115
diese Eigenschaft des Ergebnisobjekts zurückgegeben, das Tracking übergeben wird.

227
00:18:43,115 --> 00:18:49,044
Beachten Sie hier wieder, wie die Aufrufe

228
00:18:49,044 --> 00:18:54,585
in den Callback-Funktionen verschachtelt werden.

229
00:18:54,585 --> 00:18:57,880
Ich möchte, dass Sie diese Struktur des Codes

230
00:18:57,880 --> 00:19:03,130
speziell bemerken, weil das ist, worauf ich in der nächsten Übung zurückkommen werde.

231
00:19:03,130 --> 00:19:05,760
Nachdem ich das getan

232
00:19:05,760 --> 00:19:07,529
habe, werde ich die Dokumente finden,

233
00:19:07,529 --> 00:19:12,930
also lassen Sie mich das einfach kopieren und dann werde ich den gleichen Code hier verwenden.

234
00:19:13,840 --> 00:19:19,530
Also werde ich sagen, Dokumente finden.

235
00:19:20,000 --> 00:19:27,695
Drinnen hier werde ich wieder sagen, gefunden aktualisiertes Dokument.

236
00:19:27,695 --> 00:19:30,375
Dann schließlich, wenn ich damit fertig bin,

237
00:19:30,375 --> 00:19:35,855
werde ich einfach db Drop Collection aufrufen.

238
00:19:35,855 --> 00:19:38,760
Also werde ich diese Geschirr Sammlung löschen, so dass ich

239
00:19:38,760 --> 00:19:41,630
meine Datenbank bereinigen werde, so dass ich

240
00:19:41,630 --> 00:19:44,350
nichts mehr habe, weil ich für die nächste Übung

241
00:19:44,350 --> 00:19:47,230
die Datenbank bereinigen und dann mit einer saubereren Datenbank beginnen möchte.

242
00:19:47,230 --> 00:19:48,835
Also, ich werde

243
00:19:48,835 --> 00:19:57,770
die Geschirr Sammlung reinigen und dann würde dies zu einem Rückruf führen.

244
00:19:59,110 --> 00:20:07,410
Also hier drinnen werde ich eine console.log sagen,

245
00:20:07,410 --> 00:20:17,000
Sammlung fallen gelassen, und dann werde ich nur das Ergebnis ausdrucken, das hereinkam.

246
00:20:17,820 --> 00:20:25,250
Schließen Sie dann schließlich die Datenbank.

247
00:20:25,650 --> 00:20:28,895
Beachten Sie, dass die Struktur des Codes,

248
00:20:28,895 --> 00:20:34,580
DB Dokument einfügen und innerhalb der Callback-Funktion werde ich

249
00:20:34,580 --> 00:20:37,690
die nächste Funktion aufrufen und innerhalb

250
00:20:37,690 --> 00:20:39,660
des Callbacks aus, dass ich

251
00:20:39,660 --> 00:20:42,270
die nächste Funktion und innerhalb der Callback nächste Funktion aufrufen werde und so weiter.

252
00:20:42,270 --> 00:20:46,990
So sehen Sie hier einen verschachtelten Satz von Callbacks und

253
00:20:46,990 --> 00:20:52,665
einen Baum strukturierten verschachtelten Satz von Rückrufen.

254
00:20:52,665 --> 00:20:56,505
Das ist etwas, worauf du achten sollst.

255
00:20:56,505 --> 00:21:02,680
Lassen Sie uns die Änderungen speichern und gehen und schauen Sie sich diese Version unserer Anwendung an.

256
00:21:02,680 --> 00:21:04,725
Wenn Sie zum Terminal zurückkehren,

257
00:21:04,725 --> 00:21:08,045
lassen Sie mich die Anwendung ausführen.

258
00:21:08,045 --> 00:21:13,035
Also lassen Sie mich NPM start eingeben und wir werden dieses Ergebnis sehen.

259
00:21:13,035 --> 00:21:19,060
Nun, aus diesem Ergebnis können Sie sehen, dass das Dokument

260
00:21:19,060 --> 00:21:25,330
in die Sammlung eingefügt wird und das ist das Dokument, das gefunden wurde.

261
00:21:25,330 --> 00:21:26,990
Im zweiten Schritt

262
00:21:26,990 --> 00:21:31,540
finden wir das Dokument also, wenn wir das DB finden Dokument aufrufen,

263
00:21:31,540 --> 00:21:36,175
also ist dies das Dokument, das aus meiner Sammlung abgerufen wird.

264
00:21:36,175 --> 00:21:39,010
Dann bitte ich es, das Dokument damit zu aktualisieren,

265
00:21:39,010 --> 00:21:42,915
und dann werden Sie feststellen, dass es aktualisiertes Dokument sagt und dann

266
00:21:42,915 --> 00:21:46,850
hier druckt es das Ergebnis oder OPS und es sagt, N ist gleich

267
00:21:46,850 --> 00:21:51,775
einer Zahl, die als eins geändert wurde und es war in Ordnung.

268
00:21:51,775 --> 00:21:57,010
Dann druckt es das aktualisierte Dokument aus,

269
00:21:57,010 --> 00:22:02,020
wir finden das aktualisierte Dokument hier und das ist, was hier gedruckt wird,

270
00:22:02,020 --> 00:22:05,770
und beachten Sie insbesondere, dass die Beschreibung aktualisiert wurde.

271
00:22:05,770 --> 00:22:09,390
Dann schließlich hat es die Sammlung fallen gelassen.

272
00:22:09,990 --> 00:22:16,690
So sehen wir, wie diese Anwendung läuft und in der Lage ist,

273
00:22:16,690 --> 00:22:23,410
das Knotenmodul zu nutzen, das wir implementiert und dann verschiedene Datenbankoperationen durchgeführt haben.

274
00:22:23,410 --> 00:22:26,560
Damit schließen wir diese Übung ab.

275
00:22:26,560 --> 00:22:31,520
In dieser Übung habe ich Ihnen gezeigt, wie Sie mit

276
00:22:31,520 --> 00:22:37,085
Ihrem MongoDB-Server von Ihrer Knotenanwendung aus interagieren würden.

277
00:22:37,085 --> 00:22:43,455
Wir haben hier unser eigenes Knotenmodul implementiert und es dann

278
00:22:43,455 --> 00:22:46,810
innerhalb unserer Knotenanwendung verwendet, indem wir

279
00:22:46,810 --> 00:22:50,965
bestimmte Datenbankoperationen in dieses Knotenmodul kapseln.

280
00:22:50,965 --> 00:22:54,020
Dies ist ein guter Zeitpunkt für Sie, ein Git-Commit mit

281
00:22:54,020 --> 00:22:58,860
dem Nachrichtenknoten MongoDB Beispiel Teil zwei zu machen.