1
00:00:03,920 --> 00:00:10,025
Nachdem wir nun über den Knoten MongoDB-Treiber, das Knotenmodul, gelernt haben, mit

2
00:00:10,025 --> 00:00:14,205
dem unsere Knotenanwendung

3
00:00:14,205 --> 00:00:18,475
mit einem MongoDB-Server interagieren kann,

4
00:00:18,475 --> 00:00:23,430
werden wir in dieser Übung das Knotenmodul verwenden und die verschiedenen Methoden verwenden,

5
00:00:23,430 --> 00:00:29,840
die vom Knotenmodul unterstützt werden, um eine Einführung mit unserem MongoDB-Server.

6
00:00:29,840 --> 00:00:33,030
Um zu beginnen, gehen Sie zu

7
00:00:33,030 --> 00:00:38,135
dem NodeJS-Ordner, den Sie verwendet haben, um alle Ihre Beispiele zu speichern,

8
00:00:38,135 --> 00:00:45,310
und erstellen Sie dort einen neuen Ordner namens node-mongo.

9
00:00:45,320 --> 00:00:48,125
In diesem Ordner werden wir

10
00:00:48,125 --> 00:00:52,715
die NodeJS-Anwendung entwickeln, die mit unserem MongoDB-Server interagiert. Stellen

11
00:00:52,715 --> 00:00:57,140
Sie nun sicher, dass Ihr MongoDB-Server einsatzbereit ist.

12
00:00:57,140 --> 00:01:02,675
In der vorherigen Übung haben wir bereits gesehen, wie unser MongoDB-Server gestartet werden kann.

13
00:01:02,675 --> 00:01:12,060
Also, halten Sie den MongoDB-Server auf und laufen und

14
00:01:12,060 --> 00:01:15,020
gehen Sie in einem anderen Terminalfenster oder Terminal-Tab oder Befehlsfenster zu dem node-mongo-Ordner, den Sie gerade

15
00:01:15,020 --> 00:01:18,135
erstellt haben, und initialisieren Sie hier eine Knotenanwendung.

16
00:01:18,135 --> 00:01:22,910
Also, lassen Sie mich npm init eingeben und wir

17
00:01:22,910 --> 00:01:29,765
werden die Anwendung als Node-Mongo und Version,

18
00:01:29,765 --> 00:01:36,895
Beschreibung Node MongoDB Beispiel,

19
00:01:36,895 --> 00:01:39,295
und der Einstiegspunkt,

20
00:01:39,295 --> 00:01:48,980
und der Autor, genau wie wir in den vorherigen Übungen ausgefüllt haben.

21
00:01:48,980 --> 00:01:53,255
Sobald die Datei package.json initialisiert wurde,

22
00:01:53,255 --> 00:01:59,610
öffnen Sie diese im Editor Ihrer Wahl.

23
00:01:59,610 --> 00:02:02,635
Gehen Sie nun in die package.json-Datei,

24
00:02:02,635 --> 00:02:09,370
lassen Sie mich ein anderes Skript hier einführen, genau wie wir es früher getan haben, also

25
00:02:09,370 --> 00:02:16,350
sagen wir „start“: „node index“ und speichern Sie die Änderungen.

26
00:02:16,350 --> 00:02:18,010
Gehen wir zurück zum Terminal,

27
00:02:18,010 --> 00:02:22,350
lassen Sie uns das MongoDB-Knotenmodul installieren.

28
00:02:22,350 --> 00:02:30,080
Geben Sie also npm install mongodb @3 .0.10 —save ein.

29
00:02:30,080 --> 00:02:33,590
Wir werden auch das Assert-Knoten-Modul installieren, also

30
00:02:33,590 --> 00:02:39,460
sagen wir npm install assert @1 .4.1 —save.

31
00:02:39,460 --> 00:02:42,710
Das assert-Modul ermöglicht es uns, die Behauptung zu verwenden, um auf

32
00:02:42,710 --> 00:02:46,720
Wahrheit oder falsche Werte in unserer Anwendung zu überprüfen,

33
00:02:46,720 --> 00:02:49,535
und Sie werden sehen, wie ich es später verwende.

34
00:02:49,535 --> 00:02:52,645
Nun, da wir diese Knotenmodule installiert haben,

35
00:02:52,645 --> 00:02:58,355
lassen Sie uns unsere Knotenanwendung erstellen, die mit dem MongoDB-Server interagiert.

36
00:02:58,355 --> 00:03:00,455
Gehen Sie zurück zum Editor

37
00:03:00,455 --> 00:03:01,915
,

38
00:03:01,915 --> 00:03:05,465
erstellen Sie im Projektordner eine Datei namens index.js,

39
00:03:05,465 --> 00:03:07,684
und hier werden wir

40
00:03:07,684 --> 00:03:12,030
die Knotenanwendung erstellen, die mit unserem MongoDB-Server interagiert.

41
00:03:12,030 --> 00:03:14,425
Also, in dieser Anwendung,

42
00:03:14,425 --> 00:03:18,630
lassen Sie uns const Mongoclient,

43
00:03:18,800 --> 00:03:21,555
und dann werden sie sagen,

44
00:03:21,555 --> 00:03:28,160
erfordern (`mongodb`), das MongoDB-Knotenmodul, das wir bereits installiert haben,

45
00:03:28,160 --> 00:03:30,335
und dann würde dies uns mit

46
00:03:30,335 --> 00:03:38,045
dem MongoClient liefern, der uns ermöglicht, eine Verbindung mit dem MongoDB-Server herzustellen.

47
00:03:38,045 --> 00:03:47,160
Benötigen Sie auch das Assert-Modul.

48
00:03:48,830 --> 00:03:53,870
Nun, um eine Verbindung mit dem MongoDB-Server zu starten,

49
00:03:53,870 --> 00:04:03,590
lassen Sie uns einen konstanten Namen URL erstellen, die die URL sein wird, auf die der MongoDB-Server

50
00:04:03,590 --> 00:04:08,030
zugegriffen werden kann und der Babyzugriff dies ist,

51
00:04:08,030 --> 00:04:14,950
indem man mongodb: //localhost: 27017/ sagt. Daran

52
00:04:14,950 --> 00:04:19,360
erinnern, dass dies die Portnummer ist, an der Ihr MongoDB-Server

53
00:04:19,360 --> 00:04:25,025
läuft 27017 const dbname=,

54
00:04:25,025 --> 00:04:27,205
und dann werden sie sagen wir ConFusion.

55
00:04:27,205 --> 00:04:28,820
Erinnern Sie sich, dass wir

56
00:04:28,820 --> 00:04:34,060
die ConFusion-Datenbank in unserem MongoDB-Server in der vorherigen Übung erstellt haben

57
00:04:34,060 --> 00:04:39,310
, so dass wir auf die ConFusion-Datenbank zugreifen, die wir zuvor erstellt haben.

58
00:04:39,310 --> 00:04:46,240
Nun, um auf den Server zuzugreifen, sagen wir MongoClient.connect.

59
00:04:48,690 --> 00:04:54,790
Die Verbindungsmethode ermöglicht es uns, von unserem MongoDB-Server aus eine Verbindung mit dem MongoClient herzustellen,

60
00:04:54,790 --> 00:04:59,230
und dann werden wir sagen, dass dies die URL als ersten Parameter nimmt,

61
00:04:59,230 --> 00:05:02,485
die URL des MongoDB-Servers als ersten Parameter.

62
00:05:02,485 --> 00:05:06,590
Der zweite Parameter ist eine Callback-Funktion.

63
00:05:06,590 --> 00:05:14,275
Die Callback-Funktion hat also zwei Parameter, den Fehlerwert

64
00:05:14,275 --> 00:05:17,915
und den Client, mit dem wir dann

65
00:05:17,915 --> 00:05:22,405
eine Verbindung zu unserer Datenbank herstellen und dann verschiedene Operationen ausführen können.

66
00:05:22,405 --> 00:05:27,040
Also, innerhalb dieser Callback-Funktion,

67
00:05:27,040 --> 00:05:36,400
das erste, was wir tun werden, ist zu überprüfen, um sicherzustellen, dass der Fehler nicht null ist.

68
00:05:36,400 --> 00:05:39,740
Also, die Assert wird überprüfen, ob Fehler gleich null ist,

69
00:05:39,740 --> 00:05:45,640
so dass die assert-Funktion es uns ermöglicht, verschiedene Prüfungen auf Werten durchzuführen.

70
00:05:45,640 --> 00:05:48,010
Also, wir überprüfen, um sicherzustellen, dass der Fehler nicht ist,

71
00:05:48,010 --> 00:05:49,785
wenn er nicht null ist,

72
00:05:49,785 --> 00:05:55,660
dann bedeutet das, dass es einen Fehler gibt und so werden wir den Fehler auf dem Bildschirm anzeigen.

73
00:05:55,660 --> 00:05:59,650
Also, das ist die Verwendung der assert-Funktion hier.

74
00:05:59,650 --> 00:06:03,025
Nun, wenn das nicht passiert,

75
00:06:03,025 --> 00:06:07,430
dann bedeutet das, dass wir richtig mit dem Server verbunden sind,

76
00:06:07,430 --> 00:06:15,170
also sagen wir `richtig mit dem Server`

77
00:06:15,170 --> 00:06:25,120
const db= client.db (dbname), um sich mit der Datenbank zu verbinden,

78
00:06:25,120 --> 00:06:33,570
dann können wir sagen const collection db. ,

79
00:06:33,570 --> 00:06:38,810
so dass die Datenbank uns verschiedene Methoden zur Verfügung stellt, die es uns ermöglichen,

80
00:06:38,810 --> 00:06:44,380
mit dem Server zu interagieren, so sagen wir db.collection (`dishes`) Also,

81
00:06:44,380 --> 00:06:49,765
wir werden versuchen, auf die Gerichte Sammlung innerhalb dieser Datenbank zuzugreifen.

82
00:06:49,765 --> 00:06:55,175
Nun, das nächste, was wir versuchen werden, ist

83
00:06:55,175 --> 00:07:04,414
collection.insertone, also werden wir versuchen, ein Objekt in die Sammlung einzufügen,

84
00:07:04,414 --> 00:07:08,360
und dieses Objekt wäre mit

85
00:07:08,360 --> 00:07:28,510
dem Namen und der Beschreibung, „test“.

86
00:07:28,510 --> 00:07:32,520
Also, diese Sammlung bietet diese Methode namens InserTone,

87
00:07:32,520 --> 00:07:36,825
die es uns ermöglicht, ein Dokument in diese Sammlung einfügen,

88
00:07:36,825 --> 00:07:42,825
und das Dokument ist das erste Argument für diese Methode hier.

89
00:07:42,825 --> 00:07:49,780
Das zweite Argument für die Methode ist eine Callback-Funktion,

90
00:07:49,780 --> 00:07:56,720
und die Callback-Funktion nimmt zwei Parameter, Fehler und Ergebnis.

91
00:07:58,260 --> 00:08:01,000
Also, innerhalb dieser Callback-Funktion,

92
00:08:01,000 --> 00:08:03,180
wenn das Ergebnis erhalten wird,

93
00:08:03,180 --> 00:08:08,610
dann sind wir in der Lage, auf die Sammlung zuzugreifen und dann weitere Operationen auszuführen.

94
00:08:08,610 --> 00:08:16,645
Also, hier, das erste, was wir tun werden, ist zu überprüfen, um sicherzustellen, dass der Fehler nicht null ist.

95
00:08:16,645 --> 00:08:19,450
Also, wir werden dort eine Behauptung machen,

96
00:08:19,450 --> 00:08:33,470
und dann können wir hier sagen, „After Insert“.

97
00:08:37,770 --> 00:08:45,145
Also, nachdem wir einfügen, dann sehen wir, dass wir

98
00:08:45,145 --> 00:08:51,490
den Ergebniswert erhalten, der dort zurückgegeben wird, also dieses Ergebnis.

99
00:08:51,490 --> 00:08:56,070
Dieses Ergebnis wird auch

100
00:08:56,070 --> 00:09:00,805
diese OPS-Eigenschaft liefern, die besagt, wie viele Operationen gerade erfolgreich ausgeführt wurden.

101
00:09:00,805 --> 00:09:02,715
Also, das ist es, was ich drucken werde.

102
00:09:02,715 --> 00:09:05,140
Also, es wird sagen, die eingefügte Nummer ist eins.

103
00:09:05,140 --> 00:09:12,030
Also, was bedeutet, dass dieses bestimmte Dokument in die Datenbank eingefügt wurde.

104
00:09:12,070 --> 00:09:15,440
Also, das werden wir hier bestätigen.

105
00:09:15,440 --> 00:09:19,810
Dann, danach, werden wir eine andere Option durchführen,

106
00:09:19,810 --> 00:09:22,415
eine Operation für die Sammlung, und sagen wir,

107
00:09:22,415 --> 00:09:30,200
Sammlung finden, und wir werden versuchen, nach allen Datensätzen in der Sammlung zu suchen.

108
00:09:30,200 --> 00:09:37,420
Also, hier werden wir eine leere JSON-Zeichenfolge oder entsprechende Ebene JavaScript-Objekt liefern.

109
00:09:37,420 --> 00:09:40,895
Also, es wird nach allem suchen, was in der Sammlung ist,

110
00:09:40,895 --> 00:09:43,750
und dann, das uns zur Verfügung stellen.

111
00:09:43,750 --> 00:09:48,640
Dann kann dies in ein Array von JSON-Objekten konvertiert werden.

112
00:09:48,640 --> 00:09:52,215
Deshalb rufen wir das toArray auf,

113
00:09:52,215 --> 00:09:59,365
und dies nimmt eine Callback-Funktion als Parameter.

114
00:09:59,365 --> 00:10:07,065
Der erste Parameter ist natürlich der Fehlerwert, also

115
00:10:07,065 --> 00:10:16,365
überprüfen wir erneut, um sicherzustellen, dass der Fehler nicht null ist.

116
00:10:16,365 --> 00:10:25,990
Dann werden wir sagen, console.log gefunden,

117
00:10:25,990 --> 00:10:29,140
und dann drucken Sie alles, was gefunden wurde,

118
00:10:29,140 --> 00:10:32,505
und wir sagen console.log.

119
00:10:32,505 --> 00:10:35,080
Der zweite Parameter hier, docs, gibt also

120
00:10:35,080 --> 00:10:38,370
alle Dokumente aus dieser Sammlung zurück

121
00:10:38,370 --> 00:10:42,380
, die den Kriterien entsprechen, die Sie hier angeben.

122
00:10:42,380 --> 00:10:43,970
Da dies leer ist,

123
00:10:43,970 --> 00:10:47,535
bedeutet dies, dass alle Dokumente in der Sammlung an uns zurückgesendet werden.

124
00:10:47,535 --> 00:10:49,500
Sie können hier einen Filter angeben, der

125
00:10:49,500 --> 00:10:54,030
besagt, dass name gleich einem Wert ist,

126
00:10:54,030 --> 00:10:57,325
und dann werden nur die Dokumente abgerufen, die diesem Wert entsprechen.

127
00:10:57,325 --> 00:11:04,040
Also hier, lassen Sie mich einfach die Dokumente hier ausdrucken,

128
00:11:04,040 --> 00:11:07,660
um anzuzeigen, dass dieses Element

129
00:11:07,660 --> 00:11:11,990
in die Sammlung eingefügt wurde und dann abgerufen wird,

130
00:11:11,990 --> 00:11:15,950
und dann drucken wir es einfach aus, nur um sicherzustellen, dass das Dokument, das wir gerade

131
00:11:15,950 --> 00:11:20,590
in der vorherigen Operation eingefügt haben, tatsächlich in der Sammlung ist,

132
00:11:20,590 --> 00:11:22,420
und so drucken wir das hier aus.

133
00:11:22,420 --> 00:11:28,060
Nun danach werden wir

134
00:11:28,060 --> 00:11:35,880
hier die DropCollection-Methode verwenden.

135
00:11:35,880 --> 00:11:40,560
Daher wird die DropCollection die angegebene Sammlung hier löschen.

136
00:11:40,560 --> 00:11:42,410
Also, wir sagen DropCollection Gerichte,

137
00:11:42,410 --> 00:11:45,820
also werde ich nur die Geschirr Sammlung aus meiner Datenbank entfernen.

138
00:11:45,820 --> 00:11:48,180
Also, ich werde nur die Datenbank bereinigen und

139
00:11:48,180 --> 00:11:51,090
sie dann mit einer leeren Datenbank belassen, so dass wir auf

140
00:11:51,090 --> 00:11:53,610
die nächste Übung gehen können, wo wir wieder

141
00:11:53,610 --> 00:11:57,115
ähnliche Arten von Operationen ausführen können, um dies zu überprüfen.

142
00:11:57,115 --> 00:12:00,455
Dieser nimmt als zweiter Parameter

143
00:12:00,455 --> 00:12:06,815
eine Callback-Funktion, die entweder einen Fehler oder ein Ergebnis zurückgibt.

144
00:12:06,815 --> 00:12:16,040
In diesem werden wir überprüfen und sicherstellen, dass die Behauptung nicht null ist,

145
00:12:16,440 --> 00:12:20,780
und dann werden wir sagen, client.close.

146
00:12:20,780 --> 00:12:25,425
So werden wir die Verbindung zur Datenbank vor Ort schließen.

147
00:12:25,425 --> 00:12:34,465
Mit diesem einfachen Satz von Methoden ermöglichen wir uns, mit unserem Server zu interagieren,

148
00:12:34,465 --> 00:12:41,150
und es zeigt uns auch, wie wir mit dem Server kommunizieren können, indem wir die

149
00:12:41,150 --> 00:12:48,185
Methoden verwenden, die über dieses MongoDB-Knotenmodul oder den MongoDB-Treiber verfügbar sind.

150
00:12:48,185 --> 00:12:51,900
Also, hier sehen Sie, dass wir zuerst eine Einfügeoperation durchführen.

151
00:12:51,900 --> 00:12:54,875
Beachten Sie dann nach der Einfügeoperation, dass

152
00:12:54,875 --> 00:12:59,715
wir die zweite Operation innerhalb der Callback-Funktion ausführen.

153
00:12:59,715 --> 00:13:07,490
Dies stellt sicher, dass dieser Vorgang abgeschlossen wurde, bevor Sie den nächsten ausführen.

154
00:13:07,490 --> 00:13:15,680
Dies ist also ein zweiter Aufruf, der innerhalb der ersten Callback-Funktion

155
00:13:15,680 --> 00:13:19,470
und dann entsprechend darin eingeschlossen ist.

156
00:13:19,470 --> 00:13:24,370
Wir rufen die Methoden wieder hier und drinnen auf.

157
00:13:24,370 --> 00:13:28,080
Sie sehen also, dass es eine Verschachtelung dieser Anrufe gibt,

158
00:13:28,080 --> 00:13:29,435
eine innerhalb der anderen.

159
00:13:29,435 --> 00:13:32,200
Beachten Sie die Struktur, weil ich zurückkommen werde, um

160
00:13:32,200 --> 00:13:35,755
etwas darüber in einer der späteren Übungen zu erklären.

161
00:13:35,755 --> 00:13:40,235
Also, beachten Sie, dass die Verschachtelung dieser Anrufe ineinander.

162
00:13:40,235 --> 00:13:43,020
Lassen Sie uns die Änderungen speichern

163
00:13:43,210 --> 00:13:49,330
und dann sehen, was diese Anwendung tut, wenn wir sie ausführen. Wenn Sie

164
00:13:49,330 --> 00:13:51,685
wieder zum Terminal gehen,

165
00:13:51,685 --> 00:13:55,170
stellen Sie sicher, dass Ihr MongoDB-Server einsatzbereit

166
00:13:55,170 --> 00:14:00,560
ist und läuft. Wenn er ausgeführt wird, wird er viele Protokollmeldungen auf der Konsole ausdrucken.

167
00:14:00,560 --> 00:14:04,230
Wir können diese Log-Meldungen vorerst ignorieren.

168
00:14:04,230 --> 00:14:06,710
Lassen Sie uns die Knotenanwendung ausführen.

169
00:14:06,710 --> 00:14:09,330
Also, wir werden sagen, npm start,

170
00:14:09,330 --> 00:14:12,095
und wenn die Knotenanwendung ausgeführt wird,

171
00:14:12,095 --> 00:14:14,875
bemerken Sie, was Knotenanwendung tut.

172
00:14:14,875 --> 00:14:19,705
So heißt es, richtig mit dem Server verbunden, After Insert,

173
00:14:19,705 --> 00:14:22,260
dann zeigt es, dass

174
00:14:22,260 --> 00:14:28,375
dieses bestimmte Dokument in unsere MongoDB eingefügt wurde und insbesondere der Knoten,

175
00:14:28,375 --> 00:14:29,540
die ID hier angegeben.

176
00:14:29,540 --> 00:14:32,570
Beachten Sie also, dass dies nicht besagt, dass dies eine Objekt-ID ist.

177
00:14:32,570 --> 00:14:35,995
Diese ID wird automatisch

178
00:14:35,995 --> 00:14:39,730
vom Knoten Mongo-Treiber in ihr Dokument eingefügt, wenn

179
00:14:39,730 --> 00:14:43,745
Sie versuchen, sie hier in den MongoDB-Server einzufügen.

180
00:14:43,745 --> 00:14:48,950
Dieses Format ist genau das gleiche wie die Objekt-ID, die wir gesehen haben.

181
00:14:48,950 --> 00:14:53,910
Danach führten wir eine Findoperation durch.

182
00:14:53,910 --> 00:14:55,560
Also, das wird gefunden,

183
00:14:55,560 --> 00:14:58,710
und dann druckt es diesen Artikel hier aus.

184
00:14:58,710 --> 00:15:01,550
Beachten Sie, dass

185
00:15:01,550 --> 00:15:08,470
wir aus der vorherigen Übung in einem früheren Dokument, das wir in der vorherigen Übung eingefügt hatten, übrig geblieben waren.

186
00:15:08,470 --> 00:15:11,005
Also, das ist immer noch in der Sammlung hier zu sehen,

187
00:15:11,005 --> 00:15:13,500
und das neue Dokument, das wir gerade hier eingefügt haben.

188
00:15:13,500 --> 00:15:17,179
Dieses Dokument ist direkt darunter zu sehen,

189
00:15:17,179 --> 00:15:20,510
aber beachten Sie, dass diese beiden zwei verschiedene IDs haben.

190
00:15:20,510 --> 00:15:25,030
Diese ID stimmt mit der ID des Dokuments überein, das wir gerade eingefügt haben.

191
00:15:25,030 --> 00:15:28,455
Also, das ist übrig von der vorherigen Übung.

192
00:15:28,455 --> 00:15:32,765
Danach lassen wir natürlich die Sammlung fallen, so dass

193
00:15:32,765 --> 00:15:38,060
diese ganze Reihe von Dokumenten und die Geschirrsammlung aus unserer Datenbank entfernt werden.

194
00:15:38,060 --> 00:15:41,060
Also, jetzt wird unsere Datenbank sauber und leer sein.

195
00:15:41,060 --> 00:15:44,930
Das zeigt Ihnen also, wie wir

196
00:15:44,930 --> 00:15:52,900
den MongoDB-Treiber verwenden können, um von unserer Knotenanwendung mit dem Server zu kommunizieren.

197
00:15:52,900 --> 00:15:55,330
Jetzt, da wir unsere Anwendung haben,

198
00:15:55,330 --> 00:16:01,000
lassen Sie mich eine.gitignore

199
00:16:01,000 --> 00:16:06,720
hier einführen und dann Knotenmodule in die.gitignore setzen,

200
00:16:06,720 --> 00:16:10,540
und Sie verstehen schnell, warum ich das tue.

201
00:16:10,540 --> 00:16:16,595
Dann werden wir zurück gehen und das Git-Repository initialisieren und dann ein Git-Commit machen.

202
00:16:16,595 --> 00:16:18,590
Gehen Sie zurück zum Terminal,

203
00:16:18,590 --> 00:16:21,505
lassen Sie mich das Git-Repository initialisieren,

204
00:16:21,505 --> 00:16:31,460
und dann überprüfen Sie den Git-Status und Sie sehen, dass es einige nicht festgeschriebene Dateien gibt.

205
00:16:31,460 --> 00:16:37,204
Also lassen Sie mich sie einchecken und dann ein Git-Commit mit der Nachricht tun,

206
00:16:37,204 --> 00:16:46,450
Node MongoDB Beispiel eins.

207
00:16:46,450 --> 00:16:49,305
Dies ist der Teil einer der Übung,

208
00:16:49,305 --> 00:16:54,020
also überprüfen wir einfach die Elemente in unser Git-Repository.

209
00:16:54,020 --> 00:16:56,900
Damit ist diese Übung abgeschlossen.

210
00:16:56,900 --> 00:17:01,760
In dieser Übung haben wir gesehen, wie wir das Knotenmodul,

211
00:17:01,760 --> 00:17:04,365
den MongoDB-Treiber installieren, dann

212
00:17:04,365 --> 00:17:07,835
konnten wir mit unserem MongoDB-Server aus

213
00:17:07,835 --> 00:17:12,740
unserer Knotenanwendung mit den Methoden kommunizieren, die vom MongoDB-Treiber bereitgestellt werden.

214
00:17:12,740 --> 00:17:17,840
Wir werden diese Übung im nächsten Teil

215
00:17:17,840 --> 00:17:24,380
der Übung fortsetzen, wo wir ein paar weitere Methoden des MongoDB-Treibers erforschen werden.