1
00:00:03,950 --> 00:00:09,370
In questo esercizio, continueremo con l'esercizio precedente in cui abbiamo

2
00:00:09,370 --> 00:00:14,650
sviluppato l'interazione tra l'applicazione nodo e il server MongoDB.

3
00:00:14,650 --> 00:00:18,120
In questo esercizio, ho intenzione di incapsulare alcune

4
00:00:18,120 --> 00:00:21,750
delle operazioni di database in un modulo nodo a sé stante,

5
00:00:21,750 --> 00:00:23,540
un modulo nodo basato su file,

6
00:00:23,540 --> 00:00:29,345
e quindi utilizzarlo all'interno della mia applicazione nodo per interagire con il server.

7
00:00:29,345 --> 00:00:31,940
Allo stesso tempo, eseguiremo diverse operazioni

8
00:00:31,940 --> 00:00:35,630
sul server per dimostrare che saremo in

9
00:00:35,630 --> 00:00:43,040
grado di interagire con il server utilizzando la nostra applicazione nodo e il driver MongoDB nodo.

10
00:00:43,040 --> 00:00:47,605
Per iniziare, andiamo al nostro progetto

11
00:00:47,605 --> 00:00:53,975
e quindi creare un nuovo file denominato operations.js.

12
00:00:53,975 --> 00:00:57,720
Questo file incapsulerà tutte quelle operazioni del database,

13
00:00:57,720 --> 00:01:00,705
le quattro operazioni che eseguirò inserendo,

14
00:01:00,705 --> 00:01:05,855
trovando, rimuovendo e aggiornando un documento nel mio database.

15
00:01:05,855 --> 00:01:09,980
Ora, questo sarà organizzato come un modulo nodo basato su file,

16
00:01:09,980 --> 00:01:15,070
che poi lo farò uso nella mia applicazione nodo per accedere al server.

17
00:01:15,070 --> 00:01:16,330
Quindi, per iniziare,

18
00:01:16,330 --> 00:01:25,780
fammi prima richiedere asserire,

19
00:01:25,780 --> 00:01:27,565
in questo modulo nodo,

20
00:01:27,565 --> 00:01:30,225
e poiché questo sembra essere un modulo nodo,

21
00:01:30,225 --> 00:01:35,055
esporteremo diversi metodi dal modulo nodo.

22
00:01:35,055 --> 00:01:41,705
Il primo metodo sarebbe inserire il documento ovviamente come ci si aspetterebbe,

23
00:01:41,705 --> 00:01:44,520
e questo richiederà quattro parametri DB,

24
00:01:44,520 --> 00:01:49,555
il MongoDB, connessione al database all'interno della mia applicazione nodo,

25
00:01:49,555 --> 00:01:54,240
che otterrò all'interno dell'applicazione nodo.

26
00:01:54,240 --> 00:01:57,785
Poi il secondo è il documento che voglio inserire.

27
00:01:57,785 --> 00:02:02,800
Il terzo parametro è la raccolta in cui voglio inserire il documento.

28
00:02:02,800 --> 00:02:05,675
L' ultima è una funzione di callback,

29
00:02:05,675 --> 00:02:10,425
che verrà richiamata una volta completata l'operazione.

30
00:02:10,425 --> 00:02:14,800
Quindi chiudiamo la funzione qui,

31
00:02:14,800 --> 00:02:20,100
e questo essenzialmente incapsula il metodo di inserimento del documento qui.

32
00:02:20,100 --> 00:02:27,415
Quindi, questa è una funzione che viene esportata da questo modulo nodo qui.

33
00:02:27,415 --> 00:02:34,250
Ora, ho intenzione di incorporare anche alcuni altri metodi qui.

34
00:02:34,250 --> 00:02:42,870
Il secondo sarebbe trovare documenti.

35
00:02:42,870 --> 00:02:46,025
Non solo uno, ma diversi documenti.

36
00:02:46,025 --> 00:02:54,390
Questo vorrei cercare la collezione e trovare tutti i documenti che si trovano nella raccolta.

37
00:02:54,390 --> 00:02:58,130
Quindi, ecco perché sto prendendo solo il database

38
00:02:58,130 --> 00:03:02,090
e la raccolta come i due parametri insieme al callback.

39
00:03:02,090 --> 00:03:11,550
La terza funzione che ho intenzione di implementare un'esportazione da qui è il removedocument.

40
00:03:12,290 --> 00:03:15,590
Questo supporta l'operazione di eliminazione,

41
00:03:15,590 --> 00:03:19,855
e quindi il nome del documento prenderà il database, il documento,

42
00:03:19,855 --> 00:03:23,775
la raccolta e la richiamata come i quattro parametri,

43
00:03:23,775 --> 00:03:30,595
e chiameremo la richiamata al termine dell'operazione.

44
00:03:30,595 --> 00:03:34,445
L' ultimo ovviamente è quello di aggiornare il documento.

45
00:03:34,445 --> 00:03:38,120
Ora, naturalmente, non devi necessariamente farlo in questo modo.

46
00:03:38,120 --> 00:03:42,830
Ho appena sentito che questo sarebbe stato un altro modo per illustrare come è possibile

47
00:03:42,830 --> 00:03:49,110
incapsulare tali funzioni nel proprio modulo nodo.

48
00:03:49,110 --> 00:03:55,395
Questo è solo riorganizzare il codice in un modo più facile da usare.

49
00:03:55,395 --> 00:03:57,205
Quindi, per le esportazioni,

50
00:03:57,205 --> 00:04:00,070
per il documento di aggiornamento prende il DB,

51
00:04:00,070 --> 00:04:03,750
un modo per identificare il documento come secondo parametro.

52
00:04:03,750 --> 00:04:06,205
Il terzo parametro è l'aggiornamento

53
00:04:06,205 --> 00:04:08,750
e il quarto parametro è la raccolta in cui

54
00:04:08,750 --> 00:04:11,505
esiste questo documento e il callback.

55
00:04:11,505 --> 00:04:18,160
Quindi, quattro funzioni da esportare dal file operations.js.

56
00:04:18,160 --> 00:04:20,380
Ora, all'interno di queste funzioni,

57
00:04:20,380 --> 00:04:21,735
implementiamo uno per uno.

58
00:04:21,735 --> 00:04:23,420
Nel documento di inserimento,

59
00:04:23,420 --> 00:04:27,680
la prima cosa che ho intenzione di fare è dire

60
00:04:27,680 --> 00:04:36,000
const collection e dirà DB collection,

61
00:04:38,930 --> 00:04:44,710
e il parametro è la raccolta.

62
00:04:45,350 --> 00:04:50,190
Quindi, cercheremo la collezione lì.

63
00:04:50,190 --> 00:04:54,640
Ora, questo deve essere eseguito in tutti e quattro i metodi.

64
00:04:54,640 --> 00:04:59,990
Quindi, ho intenzione di andare e incollare questo codice in tutti e quattro i metodi qui,

65
00:05:01,140 --> 00:05:05,390
perché questa è una funzione di cui ho bisogno in tutti loro.

66
00:05:05,390 --> 00:05:07,820
Quindi, una volta entrato in possesso della collezione,

67
00:05:07,820 --> 00:05:11,680
come ricordi dall'esercizio precedente,

68
00:05:11,680 --> 00:05:13,895
posso eseguire operazioni sulla collezione.

69
00:05:13,895 --> 00:05:19,160
Quindi, dirò collection, insert,

70
00:05:21,300 --> 00:05:27,610
e questo prende come primo parametro il documento da inserire,

71
00:05:27,610 --> 00:05:35,695
e il secondo parametro è il callback con l'errore e quel risultato.

72
00:05:35,695 --> 00:05:40,990
Quindi, ora quando questo documento

73
00:05:40,990 --> 00:05:46,780
viene inserito chiamando il metodo insert sulla raccolta di database,

74
00:05:46,780 --> 00:05:49,180
il metodo insert lascia che ti ricordi,

75
00:05:49,180 --> 00:05:52,090
è supportato dal driver MongoDB.

76
00:05:52,090 --> 00:05:53,980
Quindi, questo è il metodo che stiamo usando qui,

77
00:05:53,980 --> 00:05:56,420
o questa è la funzione che stiamo usando qui.

78
00:05:56,420 --> 00:06:05,060
Ora, la prima cosa che ho intenzione di controllare per questo, assertequal err, null.

79
00:06:05,060 --> 00:06:09,185
Quindi, voglio assicurarmi di non avere un errore.

80
00:06:09,185 --> 00:06:11,225
Quindi voglio assicurarmi che l'errore sia nullo.

81
00:06:11,225 --> 00:06:12,470
Se non è nullo,

82
00:06:12,470 --> 00:06:15,930
questo stamperà le informazioni e quindi chiuderà l'applicazione.

83
00:06:15,930 --> 00:06:19,760
In questo momento, sento che va bene gestirlo che in seguito,

84
00:06:19,760 --> 00:06:24,680
vedremo come possiamo avere un modo globale di gestire tutti gli errori quando

85
00:06:24,680 --> 00:06:34,390
implementiamo nella prossima lezione un altro modo di accedere al database MongoDB.

86
00:06:34,390 --> 00:06:36,640
Ora, dopo averlo fatto,

87
00:06:36,640 --> 00:06:38,050
ho intenzione di implementare,

88
00:06:38,050 --> 00:06:40,075
ho intenzione di registrare semplicemente queste informazioni.

89
00:06:40,075 --> 00:06:48,570
Quindi dirò, registro della console e inserirlo.

90
00:06:48,570 --> 00:06:55,375
Quindi, questa informazione verrà stampata sullo schermo qui, inserita.

91
00:06:55,375 --> 00:07:00,440
Ora di nuovo, ricorda i punti e virgola e tutto ciò che

92
00:07:00,440 --> 00:07:05,120
è importante non dimenticarli quando stai digitando il tuo codice.

93
00:07:05,120 --> 00:07:07,930
Quindi, dirò risultato inserito.

94
00:07:07,930 --> 00:07:12,165
Questo oggetto risultato che viene restituito,

95
00:07:12,165 --> 00:07:15,785
avrà su di esso una proprietà denominata proprietà result

96
00:07:15,785 --> 00:07:20,270
e questa proprietà conterrà un valore.

97
00:07:20,270 --> 00:07:23,600
Questa proprietà risultato è anche un oggetto JavaScript,

98
00:07:23,600 --> 00:07:31,395
e questo conterrà una proprietà n che ci dice quanti documenti sono stati inseriti.

99
00:07:31,395 --> 00:07:36,875
Quindi questa è l'informazione che sto per stampare qui,

100
00:07:36,875 --> 00:07:39,540
e poi passeremo alla riga successiva e

101
00:07:39,540 --> 00:07:50,750
diremo «documenti nella collezione».

102
00:07:53,070 --> 00:08:02,040
Ora, questo è solo un modo per informare l'utente che questa operazione è avvenuta correttamente,

103
00:08:02,040 --> 00:08:10,135
e quindi passerà quel risultato alla nostra funzione di chiamata.

104
00:08:10,135 --> 00:08:15,330
Quindi, chiameremo il callback e quindi il risultato sarà il parametro per il callback.

105
00:08:15,330 --> 00:08:21,595
Quindi, quando implementiamo l'utilizzo di questa funzione nel nostro file index.js,

106
00:08:21,595 --> 00:08:23,930
forniremo il callback lì che

107
00:08:23,930 --> 00:08:26,880
riceverà il risultato come parametro in arrivo.

108
00:08:26,880 --> 00:08:30,670
Quindi, questo è per il «InsertDocument».

109
00:08:30,670 --> 00:08:33,010
Ora, per il «FindDocument

110
00:08:33,010 --> 00:08:36,750
», quello che sto per fare è dire,

111
00:08:37,010 --> 00:08:41,640
«coll.find» e ho intenzione di trovare tutti i documenti.

112
00:08:41,640 --> 00:08:44,810
Quindi, ecco perché darò un oggetto JavaScript vuoto qui,

113
00:08:44,810 --> 00:08:51,040
che corrisponderà a tutti i documenti nella raccolta e poi dirò,

114
00:08:51,040 --> 00:09:01,820
«toArray» e questo prenderà come parametro una funzione di callback,

115
00:09:02,220 --> 00:09:06,505
e all'interno di questa funzione di callback, ovviamente,

116
00:09:06,505 --> 00:09:11,710
affermerò che questo non è nullo,

117
00:09:11,710 --> 00:09:20,590
e poi diremo, «documenti di callback».

118
00:09:20,590 --> 00:09:27,440
Passeremo semplicemente indietro i documenti recuperati alla funzione chiamante.

119
00:09:28,200 --> 00:09:37,750
Ora, per il «RemoveDocument», ho intenzione di dire, «collezione DeleteOne.»

120
00:09:37,750 --> 00:09:40,270
Quindi, cercherò di trovare il primo documento che

121
00:09:40,270 --> 00:09:45,130
corrisponde a ciò che abbiamo specificato e quindi eliminarlo.

122
00:09:45,130 --> 00:09:47,070
E poi questo richiederà, ancora una volta,

123
00:09:47,070 --> 00:09:50,380
una funzione di callback come secondo parametro,

124
00:09:50,380 --> 00:09:52,685
e all'interno di questa funzione di callback,

125
00:09:52,685 --> 00:09:58,160
la prima cosa che controllo è assicurarsi che l'errore non sia nullo.

126
00:09:58,160 --> 00:10:01,820
E poi dopo di ciò, diremo,

127
00:10:02,130 --> 00:10:20,890
«il log della console ha rimosso il documento virgola.»

128
00:10:20,890 --> 00:10:24,840
Abbiamo usato la virgola qui perché si tratta di un oggetto JavaScript quindi,

129
00:10:24,840 --> 00:10:26,890
se si specifica il log della console in questo modo,

130
00:10:26,890 --> 00:10:30,360
il documento verrà stampato e quindi passeremo

131
00:10:30,360 --> 00:10:36,705
quel risultato attraverso la funzione di callback.

132
00:10:36,705 --> 00:10:47,550
E poi finalmente, per l'aggiornamento coll.UpdateOne.

133
00:10:47,670 --> 00:10:52,255
Questo è un metodo supportato dal driver MongoDB.

134
00:10:52,255 --> 00:10:56,560
Quindi, dirò, «update.one document

135
00:10:56,560 --> 00:11:01,480
", e il secondo parametro è dove

136
00:11:01,480 --> 00:11:06,960
passeremo nei campi che devono essere aggiornati.

137
00:11:06,960 --> 00:11:08,915
E il modo in cui è fatto,

138
00:11:08,915 --> 00:11:12,810
diremo, «dollaro set colon update».

139
00:11:12,810 --> 00:11:16,100
Quindi, questo prenderà le informazioni di aggiornamento che

140
00:11:16,100 --> 00:11:19,120
sto inviando e quindi le passerà in update.one.

141
00:11:19,120 --> 00:11:21,620
Il primo è il documento che deve essere aggiornato.

142
00:11:21,620 --> 00:11:25,425
Il secondo è quali campi del documento devono essere aggiornati qui.

143
00:11:25,425 --> 00:11:28,660
E il terzo parametro è nullo,

144
00:11:28,770 --> 00:11:36,305
e quell'ultimo parametro è una funzione di callback,

145
00:11:36,305 --> 00:11:45,660
che ovviamente ci darà il risultato dell'operazione.

146
00:11:45,660 --> 00:11:51,125
Quindi, la prima cosa che ho intenzione di controllare per assicurarmi che l'errore non sia nullo.

147
00:11:51,125 --> 00:11:59,535
Quindi, eseguirò un «registro della console aggiornato il documento con».

148
00:11:59,535 --> 00:12:03,195
Ora di nuovo, i log della console sono puramente per noi per

149
00:12:03,195 --> 00:12:07,920
garantire che il codice stia facendo quello che sta facendo.

150
00:12:07,920 --> 00:12:09,690
Non aiuta in alcun modo.

151
00:12:09,690 --> 00:12:11,995
Questo è solo per nostra informazione.

152
00:12:11,995 --> 00:12:15,070
In un server di produzione,

153
00:12:15,070 --> 00:12:18,570
non avresti questi registri della console, forse.

154
00:12:18,570 --> 00:12:24,220
Puoi disabilitarli. Quindi, questo è tutto.

155
00:12:24,220 --> 00:12:32,370
Quindi quattro metodi supportati in questo particolare modulo nodo basato su file inserire,

156
00:12:32,370 --> 00:12:35,040
trovare, rimuovere e aggiornare.

157
00:12:35,040 --> 00:12:38,490
Quindi, ora che abbiamo implementato questo modulo nodo basato su file,

158
00:12:38,490 --> 00:12:41,185
andiamo al file index.js,

159
00:12:41,185 --> 00:12:45,985
e quindi per fare uso di quel modulo nodo basato su file,

160
00:12:45,985 --> 00:12:48,010
ho bisogno di questo qui.

161
00:12:48,010 --> 00:12:53,969
Quindi, dirò, «const dboper richiede.»

162
00:12:53,969 --> 00:13:00,155
Poiché si tratta di un modulo nodo basato su file, si ottiene il percorso completo del modulo nodo,

163
00:13:00,155 --> 00:13:03,865
e che in questo caso è. /operations

164
00:13:03,865 --> 00:13:09,760
perché si trova nella stessa cartella del mio file index.js.

165
00:13:09,760 --> 00:13:12,400
Ora, una volta fatto questo,

166
00:13:12,400 --> 00:13:19,570
allora proprio qui, questa funzione,

167
00:13:19,570 --> 00:13:24,355
questo codice che stavamo facendo per accedere al database ora inserire,

168
00:13:24,355 --> 00:13:32,430
useremo il dboper che abbiamo appena implementato per accedere a quel database.

169
00:13:32,430 --> 00:13:36,280
Quindi, diremo, «dboper insert document,

170
00:13:36,280 --> 00:13:40,345
" e questo «insert document» prende il db come primo parametro.

171
00:13:40,345 --> 00:13:45,015
Il db qui, è questo db che è entrato quando chiamiamo MongoClient connect. In

172
00:13:45,015 --> 00:13:48,010
modo che db venga passato, in modo che

173
00:13:48,010 --> 00:13:53,805
il mio modulo del nodo operativo sappia dove accedere al database.

174
00:13:53,805 --> 00:13:59,325
Quindi il secondo parametro è il,

175
00:13:59,325 --> 00:14:03,950
quindi se guardi il «inserisci documento» vedrai

176
00:14:03,950 --> 00:14:08,055
che il secondo parametro è il documento da inserire.

177
00:14:08,055 --> 00:14:10,850
Quindi, dirò, «nome. «

178
00:14:11,640 --> 00:14:21,680
Ho solo intenzione di costruire un oggetto JSON o un oggetto JavaScript qui,

179
00:14:21,680 --> 00:14:27,315
che verrà automaticamente mappato nell'oggetto adiacente quando viene inserito.

180
00:14:27,315 --> 00:14:30,135
E il terzo parametro, come vedi,

181
00:14:30,135 --> 00:14:32,790
«raccolta di documenti db e callback».

182
00:14:32,790 --> 00:14:36,690
Quindi il terzo parametro è la collezione e la collezione è

183
00:14:36,690 --> 00:14:42,855
la collezione di piatti e quello finale è il callback.

184
00:14:42,855 --> 00:14:48,605
La richiamata di nuovo come si ricorda riceve il risultato.

185
00:14:48,605 --> 00:14:52,710
Se si guarda indietro al bambino implementato il documento di inserimento,

186
00:14:52,710 --> 00:14:55,245
il callback ha ricevuto il risultato come parametro.

187
00:14:55,245 --> 00:15:00,305
Quindi all'interno di questo callback gestiremo quel valore del risultato qui.

188
00:15:00,305 --> 00:15:07,000
Quindi, quando arriva il valore del risultato faremo un console.log.

189
00:15:07,390 --> 00:15:12,750
Diciamo inserire il documento

190
00:15:13,240 --> 00:15:20,565
backslash N e diremo risultato OPS.

191
00:15:20,565 --> 00:15:24,760
L' OPS indica il numero di operazioni di inserimento eseguite.

192
00:15:24,760 --> 00:15:28,680
Quindi questo è un altro oggetto che sarà sull'

193
00:15:28,680 --> 00:15:31,790
oggetto JavaScript risultato che viene passato come

194
00:15:31,790 --> 00:15:34,650
parametro e quindi ho intenzione di stampare quel valore.

195
00:15:34,650 --> 00:15:38,260
Quindi questo ci dara' qualche informazione su quello che e' successo.

196
00:15:38,260 --> 00:15:40,610
Ora, una volta completato,

197
00:15:40,610 --> 00:15:45,880
all'interno di questa funzione di callback chiamerò la prossima operazione di database.

198
00:15:45,880 --> 00:15:50,730
Quindi dirò dboper e poi troverò i documenti.

199
00:15:50,730 --> 00:16:00,260
Quindi dirò dbserve e il terzo parametro è docs,

200
00:16:00,260 --> 00:16:03,090
che è la funzione di callback.

201
00:16:03,090 --> 00:16:06,100
Quando ricevo i documenti, farò un

202
00:16:06,100 --> 00:16:15,170
console.log dicendo documenti trovati,

203
00:16:16,170 --> 00:16:22,140
e bloccheremo semplicemente i documenti sullo schermo.

204
00:16:22,140 --> 00:16:25,075
Quindi, questo stamperà i documenti trovati.

205
00:16:25,075 --> 00:16:28,470
Si noti che questa chiamata si trova

206
00:16:28,470 --> 00:16:37,480
all'interno della funzione di callback applicata per la chiamata di funzione precedente,

207
00:16:37,480 --> 00:16:41,225
quindi è qualcosa che voglio che tu noti in modo specifico.

208
00:16:41,225 --> 00:16:46,290
Ora, di nuovo all'interno di questa chiamata di funzione hanno bisogno di farlo in questo modo perché finché non

209
00:16:46,290 --> 00:16:52,185
viene chiamato questo callback non possiamo fare la prossima operazione.

210
00:16:52,185 --> 00:16:58,855
Quindi, in quella prossima operazione aggiornerò il documento che ho appena inserito.

211
00:16:58,855 --> 00:17:03,990
Quindi dirò aggiorna il documento e dirò Aggiorna DB documento,

212
00:17:03,990 --> 00:17:07,880
e quindi il prossimo parametro è il documento

213
00:17:07,880 --> 00:17:11,800
e non ho bisogno di specificare l'intero documento posso specificare solo un campo e

214
00:17:11,800 --> 00:17:20,740
quindi troverà il documento che corrisponde a questo particolare campo.

215
00:17:21,960 --> 00:17:27,690
Quello che ho intenzione di fare è il prossimo parametro è l'aggiornamento che deve essere fornito.

216
00:17:27,690 --> 00:17:30,770
Quindi, l'aggiornamento è quale campo voglio aggiornare,

217
00:17:30,770 --> 00:17:35,350
quindi aggiornerò

218
00:17:35,350 --> 00:17:42,050
il campo di descrizione dicendo Test aggiornato,

219
00:17:43,030 --> 00:17:48,475
e quindi il quarto è la raccolta che è Dips,

220
00:17:48,475 --> 00:17:53,820
e quello finale è la funzione di callback che ottiene

221
00:17:53,820 --> 00:18:01,110
i documenti come valore di ritorno o

222
00:18:01,110 --> 00:18:08,705
meglio risultato dell'operazione di aggiornamento che abbiamo appena eseguito.

223
00:18:08,705 --> 00:18:11,890
Quindi all'interno di questa funzione di callback,

224
00:18:11,890 --> 00:18:20,845
farò di nuovo un console.log dicendo

225
00:18:20,845 --> 00:18:31,050
backslash del documento aggiornato N. Il documento aggiornato verrà

226
00:18:31,050 --> 00:18:38,125
restituito in result.result su

227
00:18:38,125 --> 00:18:43,115
questa proprietà dell'oggetto risultato che viene passato il monitoraggio.

228
00:18:43,115 --> 00:18:49,044
Ancora una volta nota come le chiamate vengono annidate

229
00:18:49,044 --> 00:18:54,585
all'interno delle funzioni di callback qui.

230
00:18:54,585 --> 00:18:57,880
Voglio che tu noti questa struttura del codice

231
00:18:57,880 --> 00:19:03,130
in particolare perché questo è ciò a cui tornerò nel prossimo esercizio.

232
00:19:03,130 --> 00:19:05,760
Ora, dopo averlo fatto,

233
00:19:05,760 --> 00:19:07,529
troverò i documenti,

234
00:19:07,529 --> 00:19:12,930
quindi lasciami copiare e poi userò lo stesso codice qui.

235
00:19:13,840 --> 00:19:19,530
Quindi dirò, trova documenti.

236
00:19:20,000 --> 00:19:27,695
Qui dentro ho di nuovo intenzione di dire, trovato documento aggiornato.

237
00:19:27,695 --> 00:19:30,375
Poi finalmente quando ho finito con questo,

238
00:19:30,375 --> 00:19:35,855
chiamerò semplicemente db drop collection.

239
00:19:35,855 --> 00:19:38,760
Quindi ho intenzione di eliminare questa collezione di piatti in modo

240
00:19:38,760 --> 00:19:41,630
da pulire il mio database in modo da non avere

241
00:19:41,630 --> 00:19:44,350
nulla di più perché per il prossimo esercizio voglio pulire

242
00:19:44,350 --> 00:19:47,230
il database e quindi iniziare con un database più pulito.

243
00:19:47,230 --> 00:19:48,835
Quindi, ho intenzione di pulire

244
00:19:48,835 --> 00:19:57,770
la collezione di piatti e quindi questo si tradurrebbe in una richiamata.

245
00:19:59,110 --> 00:20:07,410
Quindi dentro qui ho intenzione di fare un dicendo console.log,

246
00:20:07,410 --> 00:20:17,000
raccolta abbandonata, e poi stamperò il risultato che è arrivato.

247
00:20:17,820 --> 00:20:25,250
Quindi, infine, chiudere il database.

248
00:20:25,650 --> 00:20:28,895
Si noti che la struttura del codice, il

249
00:20:28,895 --> 00:20:34,580
documento di inserimento DB e all'interno della funzione di callback chiamerò

250
00:20:34,580 --> 00:20:37,690
la funzione successiva e

251
00:20:37,690 --> 00:20:39,660
all'interno del callback off che chiamerò

252
00:20:39,660 --> 00:20:42,270
la funzione successiva e all'interno della funzione di callback successiva e così via.

253
00:20:42,270 --> 00:20:46,990
Quindi, vedi un set nidificato di callback qui e

254
00:20:46,990 --> 00:20:52,665
un set nidificato strutturato ad albero di richiami qui.

255
00:20:52,665 --> 00:20:56,505
E' una cosa a cui voglio che tu presti attenzione.

256
00:20:56,505 --> 00:21:02,680
Salviamo le modifiche e andiamo a guardare questa versione della nostra applicazione.

257
00:21:02,680 --> 00:21:04,725
Tornando al terminale,

258
00:21:04,725 --> 00:21:08,045
lasciami eseguire l'applicazione.

259
00:21:08,045 --> 00:21:13,035
Quindi fammi digitare NPM start e vedremo quel risultato.

260
00:21:13,035 --> 00:21:19,060
Ora, da questo risultato si può vedere che il documento è

261
00:21:19,060 --> 00:21:25,330
inserito nella raccolta e che è il documento che è stato trovato.

262
00:21:25,330 --> 00:21:26,990
Nel secondo passaggio,

263
00:21:26,990 --> 00:21:31,540
stiamo trovando il documento in modo che quando chiamiamo il documento DB find,

264
00:21:31,540 --> 00:21:36,175
quindi questo è il documento che viene recuperato dalla mia collezione.

265
00:21:36,175 --> 00:21:39,010
Quindi gli chiedo di aggiornare il documento con

266
00:21:39,010 --> 00:21:42,915
questo e poi noterai che dice documento aggiornato e poi

267
00:21:42,915 --> 00:21:46,850
qui stampa il risultato o OPS e dice N è uguale a

268
00:21:46,850 --> 00:21:51,775
un numero modificato come uno ed è andato bene.

269
00:21:51,775 --> 00:21:57,010
Poi stampa il documento aggiornato,

270
00:21:57,010 --> 00:22:02,020
troviamo il documento aggiornato qui e questo è ciò che viene stampato qui,

271
00:22:02,020 --> 00:22:05,770
e notare in particolare che la descrizione è stata aggiornata.

272
00:22:05,770 --> 00:22:09,390
Poi, alla fine, ha lasciato cadere la collezione.

273
00:22:09,990 --> 00:22:16,690
Quindi vediamo come questa applicazione viene eseguita ed è in grado di fare uso

274
00:22:16,690 --> 00:22:23,410
del modulo nodo che abbiamo implementato e quindi eseguito varie operazioni di database.

275
00:22:23,410 --> 00:22:26,560
Con questo completiamo questo esercizio.

276
00:22:26,560 --> 00:22:31,520
In questo esercizio ti ho dimostrato come interagiresti con

277
00:22:31,520 --> 00:22:37,085
il tuo server MongoDB dalla tua applicazione nodo.

278
00:22:37,085 --> 00:22:43,455
Abbiamo implementato il nostro modulo nodo qui e poi utilizzato

279
00:22:43,455 --> 00:22:46,810
all'interno della nostra applicazione nodo incapsulando

280
00:22:46,810 --> 00:22:50,965
alcune delle operazioni di database in quel modulo nodo.

281
00:22:50,965 --> 00:22:54,020
Questo è un buon momento per fare un commit Git con

282
00:22:54,020 --> 00:22:58,860
il nodo messaggio MongoDB esempio parte due.