1
00:00:03,920 --> 00:00:10,025
Ora che abbiamo imparato a conoscere il driver nodo MongoDB, il modulo nodo,

2
00:00:10,025 --> 00:00:14,205
che consente alla nostra applicazione nodo di essere in grado di interagire

3
00:00:14,205 --> 00:00:18,475
con un server MongoDB, in questo esercizio,

4
00:00:18,475 --> 00:00:23,430
useremo il modulo nodo e utilizzare i vari metodi che sono

5
00:00:23,430 --> 00:00:29,840
supportati dal modulo nodo per fornire introduzione con il nostro server MongoDB.

6
00:00:29,840 --> 00:00:33,030
Per iniziare, vai

7
00:00:33,030 --> 00:00:38,135
alla cartella NodeJS che hai utilizzato per memorizzare tutti i tuoi esempi

8
00:00:38,135 --> 00:00:45,310
e quindi crea una nuova cartella lì denominata node-mongo.

9
00:00:45,320 --> 00:00:48,125
In questa cartella, svilupperemo

10
00:00:48,125 --> 00:00:52,715
l'applicazione NodeJS che interagisce con il nostro server MongoDB.

11
00:00:52,715 --> 00:00:57,140
Ora, assicurati che il tuo server MongoDB sia attivo e funzionante,

12
00:00:57,140 --> 00:01:02,675
quindi nell'esercizio precedente abbiamo già visto come il nostro server MongoDB può essere avviato.

13
00:01:02,675 --> 00:01:07,370
Quindi, mantenere il server MongoDB attivo e in esecuzione e in

14
00:01:07,370 --> 00:01:12,060
altra finestra del terminale o scheda terminale o finestra di comando,

15
00:01:12,060 --> 00:01:15,020
andare alla cartella node-mongo che hai appena

16
00:01:15,020 --> 00:01:18,135
creato e inizializzare un'applicazione nodo qui.

17
00:01:18,135 --> 00:01:22,910
Quindi, lasciami digitare npm init e

18
00:01:22,910 --> 00:01:29,765
chiameremo l'applicazione come Node-Mongo e versione,

19
00:01:29,765 --> 00:01:36,895
descrizione Nodo MongoDB Esempio,

20
00:01:36,895 --> 00:01:39,295
e il punto di ingresso,

21
00:01:39,295 --> 00:01:48,980
e l'autore, proprio come abbiamo compilato gli esercizi precedenti.

22
00:01:48,980 --> 00:01:53,255
Quindi, una volta inizializzato il file package.json,

23
00:01:53,255 --> 00:01:59,610
aprilo nell'editor di tua scelta.

24
00:01:59,610 --> 00:02:02,635
Ora andando nel file package.json,

25
00:02:02,635 --> 00:02:09,370
lasciami introdurre un altro script qui proprio come abbiamo fatto in precedenza, quindi,

26
00:02:09,370 --> 00:02:16,350
diremo «start»: «node index» e salvare le modifiche.

27
00:02:16,350 --> 00:02:18,010
Tornando al terminale,

28
00:02:18,010 --> 00:02:22,350
installiamo il modulo nodo MongoDB.

29
00:02:22,350 --> 00:02:30,080
Quindi, digita npm install mongodb @3 .0.10 —save.

30
00:02:30,080 --> 00:02:33,590
Installeremo anche il modulo nodo assert, quindi,

31
00:02:33,590 --> 00:02:39,460
diremo npm install assert @1 .4.1 —save.

32
00:02:39,460 --> 00:02:42,710
Il modulo assert ci permette di utilizzare l'asserzione

33
00:02:42,710 --> 00:02:46,720
per verificare la verità o i valori falsi all'interno della nostra applicazione,

34
00:02:46,720 --> 00:02:49,535
e vedrete me usarlo più tardi.

35
00:02:49,535 --> 00:02:52,645
Ora che abbiamo installato questi moduli nodo,

36
00:02:52,645 --> 00:02:58,355
creiamo la nostra applicazione nodo che interagisce con il server MongoDB.

37
00:02:58,355 --> 00:03:00,455
Tornando all'editor,

38
00:03:00,455 --> 00:03:01,915
nella cartella del progetto,

39
00:03:01,915 --> 00:03:05,465
creare un file chiamato index.js,

40
00:03:05,465 --> 00:03:07,684
ed è qui che creeremo

41
00:03:07,684 --> 00:03:12,030
l'applicazione nodo che interagisce con il nostro server MongoDB.

42
00:03:12,030 --> 00:03:14,425
Quindi, in questa applicazione,

43
00:03:14,425 --> 00:03:18,630
scriviamo const Mongoclient,

44
00:03:18,800 --> 00:03:21,555
e poi diranno,

45
00:03:21,555 --> 00:03:28,160
require (`mongodb`), il modulo nodo MongoDB che abbiamo già installato,

46
00:03:28,160 --> 00:03:30,335
e quindi questo ci fornirebbe

47
00:03:30,335 --> 00:03:38,045
il MongoClient che ci permette di connetterci al server MongoDB.

48
00:03:38,045 --> 00:03:47,160
Inoltre, richiedere il modulo assert.

49
00:03:48,830 --> 00:03:53,870
Ora, per avviare una connessione al server MongoDB,

50
00:03:53,870 --> 00:04:03,590
creiamo un URL di nome costante che sarà l'URL in cui è possibile

51
00:04:03,590 --> 00:04:08,030
accedere al server MongoDB e l'accesso bambino questo è

52
00:04:08,030 --> 00:04:14,950
dicendo mongodb: //localhost: 27017/.

53
00:04:14,950 --> 00:04:19,360
Ricordiamo che questo è il numero di porta in cui il tuo server MongoDB sta

54
00:04:19,360 --> 00:04:25,025
eseguendo 27017 const dbname=,

55
00:04:25,025 --> 00:04:27,205
e poi diremo Confusione.

56
00:04:27,205 --> 00:04:28,820
Ricordiamo che abbiamo creato

57
00:04:28,820 --> 00:04:34,060
il database Confusione nel nostro server MongoDB nell'esercizio precedente,

58
00:04:34,060 --> 00:04:39,310
quindi, stiamo andando ad accedere che il database Confusione che abbiamo creato in precedenza.

59
00:04:39,310 --> 00:04:46,240
Ora, per accedere al server, diremo MongoClient.connect.

60
00:04:48,690 --> 00:04:54,790
Quindi, il metodo di connessione ci permette di connetterci al MongoClient dal nostro server MongoDB,

61
00:04:54,790 --> 00:04:59,230
e poi diremo che questo prende l'URL come primo parametro,

62
00:04:59,230 --> 00:05:02,485
l'URL del server MongoDB come primo parametro.

63
00:05:02,485 --> 00:05:06,590
Il secondo parametro è una funzione di callback.

64
00:05:06,590 --> 00:05:14,275
Quindi, la funzione di callback ha due parametri, il valore di errore,

65
00:05:14,275 --> 00:05:17,915
e client, che possiamo quindi utilizzare

66
00:05:17,915 --> 00:05:22,405
per connettersi al nostro database e quindi eseguire varie operazioni.

67
00:05:22,405 --> 00:05:27,040
Quindi, all'interno di questa funzione di callback, la

68
00:05:27,040 --> 00:05:36,400
prima cosa che faremo è controllare per assicurarsi che l'errore non sia nullo.

69
00:05:36,400 --> 00:05:39,740
Quindi, l'asserzione controllerà per vedere se l'errore è uguale a null,

70
00:05:39,740 --> 00:05:45,640
quindi la funzione assert ci consente di eseguire vari controlli sui valori.

71
00:05:45,640 --> 00:05:48,010
Quindi, controlliamo per assicurarci che l'errore non

72
00:05:48,010 --> 00:05:49,785
sia, se non è nullo,

73
00:05:49,785 --> 00:05:55,660
allora ciò significa che c'è un errore e quindi mostreremo l'errore sullo schermo.

74
00:05:55,660 --> 00:05:59,650
Quindi, questo è l'uso della funzione assert qui.

75
00:05:59,650 --> 00:06:03,025
Ora, se ciò non accade,

76
00:06:03,025 --> 00:06:07,430
allora ciò significa che ci siamo collegati correttamente al server,

77
00:06:07,430 --> 00:06:15,170
quindi diremo `connesso correttamente al server`

78
00:06:15,170 --> 00:06:25,120
const db= client.db (dbname) per connettersi al database,

79
00:06:25,120 --> 00:06:33,570
allora possiamo dire const collection db. ,

80
00:06:33,570 --> 00:06:38,810
quindi il db ci fornirà vari metodi che ci permettono di

81
00:06:38,810 --> 00:06:44,380
interagire con il server, quindi diremo db.collection (`dishes`) Quindi,

82
00:06:44,380 --> 00:06:49,765
cercheremo di accedere alla raccolta di piatti all'interno di questo database.

83
00:06:49,765 --> 00:06:55,175
Ora, la prossima cosa che cercheremo di fare è

84
00:06:55,175 --> 00:07:04,414
collection.insertone quindi cercheremo di inserire un oggetto nella raccolta,

85
00:07:04,414 --> 00:07:08,360
e questo oggetto sarebbe con

86
00:07:08,360 --> 00:07:28,510
il nome e la descrizione, «test».

87
00:07:28,510 --> 00:07:32,520
Quindi, questa raccolta fornisce questo metodo chiamato

88
00:07:32,520 --> 00:07:36,825
InsertOne, che ci permette di inserire un documento in questa raccolta,

89
00:07:36,825 --> 00:07:42,825
e il documento è il primo argomento di questo metodo qui.

90
00:07:42,825 --> 00:07:49,780
Il secondo argomento del metodo è una funzione di callback

91
00:07:49,780 --> 00:07:56,720
e la funzione di callback accetta due parametri, errore e risultato.

92
00:07:58,260 --> 00:08:01,000
Quindi, all'interno di questa funzione di callback,

93
00:08:01,000 --> 00:08:03,180
se si ottiene il risultato,

94
00:08:03,180 --> 00:08:08,610
allora siamo in grado di accedere alla raccolta e quindi eseguire ulteriori operazioni.

95
00:08:08,610 --> 00:08:16,645
Quindi, qui, la prima cosa che faremo è controllare per assicurarsi che l'errore non sia nullo.

96
00:08:16,645 --> 00:08:19,450
Quindi, faremo un'affermazione lì,

97
00:08:19,450 --> 00:08:33,470
e poi qui possiamo dire, «Dopo l'inserimento».

98
00:08:37,770 --> 00:08:45,145
Quindi, dopo aver inserito, vediamo che

99
00:08:45,145 --> 00:08:51,490
otteniamo il valore del risultato che viene restituito lì, quindi questo risultato.

100
00:08:51,490 --> 00:08:56,070
Questo risultato fornirà anche

101
00:08:56,070 --> 00:09:00,805
questa proprietà OPS che indica quante operazioni sono state eseguite con successo.

102
00:09:00,805 --> 00:09:02,715
Quindi, questo è quello che ho intenzione di stampare.

103
00:09:02,715 --> 00:09:05,140
Quindi, dirà che il numero inserito è uno.

104
00:09:05,140 --> 00:09:12,030
Quindi, il che significa che questo particolare documento è stato inserito nel database.

105
00:09:12,070 --> 00:09:15,440
Quindi, questo è quello che confermeremo qui.

106
00:09:15,440 --> 00:09:19,810
Quindi, dopo di che, eseguiremo un'altra opzione,

107
00:09:19,810 --> 00:09:22,415
un'operazione sulla raccolta, e diciamo

108
00:09:22,415 --> 00:09:30,200
, raccolta trova, e cercheremo di cercare tutti i record nella raccolta.

109
00:09:30,200 --> 00:09:37,420
Quindi, qui, forniremo una stringa JSON vuota o corrispondente oggetto JavaScript livello.

110
00:09:37,420 --> 00:09:40,895
Quindi, cercherà tutto quello che c'è nella collezione,

111
00:09:40,895 --> 00:09:43,750
e poi, ci fornirà questo.

112
00:09:43,750 --> 00:09:48,640
Quindi, questo può essere convertito in un array di oggetti JSON.

113
00:09:48,640 --> 00:09:52,215
Quindi, questo è il motivo per cui chiamiamo il toArray,

114
00:09:52,215 --> 00:09:59,365
e questo prende una funzione di callback come parametro.

115
00:09:59,365 --> 00:10:07,065
Il primo parametro ovviamente è il valore di errore, quindi ancora una volta,

116
00:10:07,065 --> 00:10:16,365
controlliamo per assicurarci che l'errore non sia nullo.

117
00:10:16,365 --> 00:10:25,990
Quindi diremo, console.log trovato,

118
00:10:25,990 --> 00:10:29,140
e poi stampare tutto ciò che è stato trovato,

119
00:10:29,140 --> 00:10:32,505
e diremo console.log.

120
00:10:32,505 --> 00:10:35,080
Quindi, il secondo parametro qui, documenti,

121
00:10:35,080 --> 00:10:38,370
restituirà tutti i documenti di questa raccolta

122
00:10:38,370 --> 00:10:42,380
che corrispondono a qualsiasi criterio specificato qui.

123
00:10:42,380 --> 00:10:43,970
Poiché questo è vuoto,

124
00:10:43,970 --> 00:10:47,535
allora ciò significa che tutti i documenti nella raccolta verranno restituiti a noi.

125
00:10:47,535 --> 00:10:49,500
È possibile specificare un filtro qui,

126
00:10:49,500 --> 00:10:54,030
dicendo che nome è uguale a un valore,

127
00:10:54,030 --> 00:10:57,325
e quindi verranno recuperati solo i documenti che corrispondono a tale valore.

128
00:10:57,325 --> 00:11:04,040
Quindi qui, lasciami stampare i documenti qui,

129
00:11:04,040 --> 00:11:07,660
per indicare che questo elemento è

130
00:11:07,660 --> 00:11:11,990
stato inserito nella raccolta e quindi verrà recuperato,

131
00:11:11,990 --> 00:11:15,950
e poi lo stamperemo solo per assicurarci che il documento che abbiamo appena

132
00:11:15,950 --> 00:11:20,590
inserito nell'operazione precedente sia effettivamente nella raccolta,

133
00:11:20,590 --> 00:11:22,420
e quindi lo stamperemo qui.

134
00:11:22,420 --> 00:11:28,060
Ora dopo questo, allora useremo

135
00:11:28,060 --> 00:11:35,880
il metodo DropCollection qui.

136
00:11:35,880 --> 00:11:40,560
Quindi, DropCollection rilascerà la raccolta specificata qui.

137
00:11:40,560 --> 00:11:42,410
Quindi, diremo piatti DropCollection,

138
00:11:42,410 --> 00:11:45,820
quindi ho intenzione di rimuovere la collezione di piatti dal mio database.

139
00:11:45,820 --> 00:11:48,180
Quindi, sto solo andando a pulire il database e poi

140
00:11:48,180 --> 00:11:51,090
lasciarlo con un database vuoto in modo che possiamo andare

141
00:11:51,090 --> 00:11:53,610
al prossimo esercizio in cui possiamo nuovamente

142
00:11:53,610 --> 00:11:57,115
eseguire operazioni simili per controllare questo.

143
00:11:57,115 --> 00:12:00,455
Questo prende, come secondo parametro,

144
00:12:00,455 --> 00:12:06,815
una funzione di callback che restituisce un errore o un risultato.

145
00:12:06,815 --> 00:12:16,040
All' interno di questo, controlleremo e faremo in modo che l'affermazione non sia nullo,

146
00:12:16,440 --> 00:12:20,780
e poi diremo, client.close.

147
00:12:20,780 --> 00:12:25,425
Quindi chiuderemo la connessione al database sul posto.

148
00:12:25,425 --> 00:12:34,465
Quindi con questo, questo semplice insieme di metodi ci permettono di interagire con il nostro server,

149
00:12:34,465 --> 00:12:41,150
e anche ci dimostra come possiamo comunicare con il server utilizzando

150
00:12:41,150 --> 00:12:48,185
i metodi che sono disponibili attraverso questo modulo nodo MongoDB o il driver MongoDB.

151
00:12:48,185 --> 00:12:51,900
Quindi, qui, vedi che per prima cosa eseguiamo un'operazione di inserimento.

152
00:12:51,900 --> 00:12:54,875
Quindi, dopo l'operazione di inserimento, si noti che,

153
00:12:54,875 --> 00:12:59,715
stiamo facendo la seconda operazione all'interno della funzione di callback.

154
00:12:59,715 --> 00:13:07,490
Quindi, questo assicura che questa operazione sia stata completata prima di eseguire quella successiva.

155
00:13:07,490 --> 00:13:15,680
Quindi, questa è una seconda chiamata che è racchiusa all'interno della prima funzione di callback,

156
00:13:15,680 --> 00:13:19,470
e quindi corrispondentemente, all'interno di quella.

157
00:13:19,470 --> 00:13:24,370
Stiamo ancora chiamando i metodi qui e dentro lì.

158
00:13:24,370 --> 00:13:28,080
Quindi, vedi che c'è un nidificazione di queste chiamate,

159
00:13:28,080 --> 00:13:29,435
una dentro l'altra.

160
00:13:29,435 --> 00:13:32,200
Nota la struttura perché ho intenzione di tornare per

161
00:13:32,200 --> 00:13:35,755
spiegare qualcosa su questo in uno degli esercizi successivi.

162
00:13:35,755 --> 00:13:40,235
Quindi, nota che, nidificazione di queste chiamate uno all'interno dell'altro.

163
00:13:40,235 --> 00:13:43,020
Salviamo le modifiche

164
00:13:43,210 --> 00:13:49,330
e quindi vediamo cosa fa questa applicazione quando la eseguiamo.

165
00:13:49,330 --> 00:13:51,685
Tornando al terminale, di nuovo,

166
00:13:51,685 --> 00:13:55,170
assicurati che il tuo server MongoDB sia attivo e funzionante, e così,

167
00:13:55,170 --> 00:14:00,560
quando è in esecuzione, stamperà molti messaggi di registro sulla console.

168
00:14:00,560 --> 00:14:04,230
Possiamo ignorare quei messaggi di registro per ora.

169
00:14:04,230 --> 00:14:06,710
Eseguiamo l'applicazione nodo.

170
00:14:06,710 --> 00:14:09,330
Quindi, diremo, npm start,

171
00:14:09,330 --> 00:14:12,095
e quando viene eseguita l'applicazione nodo,

172
00:14:12,095 --> 00:14:14,875
si nota cosa fa l'applicazione nodo.

173
00:14:14,875 --> 00:14:19,705
Così dice, collegato correttamente al server, Dopo inserire,

174
00:14:19,705 --> 00:14:22,260
poi mostra che

175
00:14:22,260 --> 00:14:28,375
questo particolare documento è stato inserito nel nostro MongoDB e il nodo in particolare,

176
00:14:28,375 --> 00:14:29,540
l'ID fornito qui.

177
00:14:29,540 --> 00:14:32,570
Quindi, nota che questo non dice che questo è un ID oggetto.

178
00:14:32,570 --> 00:14:35,995
Questo ID viene inserito automaticamente

179
00:14:35,995 --> 00:14:39,730
dal driver Mongo nodo nel loro documento quando

180
00:14:39,730 --> 00:14:43,745
si tenta di inserirlo nel server MongoDB qui.

181
00:14:43,745 --> 00:14:48,950
Questo formato è esattamente lo stesso dell'ID oggetto che abbiamo visto.

182
00:14:48,950 --> 00:14:53,910
Successivamente, abbiamo eseguito un'operazione di ritrovamento.

183
00:14:53,910 --> 00:14:55,560
Quindi, questo viene trovato,

184
00:14:55,560 --> 00:14:58,710
e poi stampa questo oggetto qui.

185
00:14:58,710 --> 00:15:01,550
Si noti che dall'esercizio precedente,

186
00:15:01,550 --> 00:15:08,470
avevamo lasciato nel documento precedente che avevamo inserito nell'esercizio precedente.

187
00:15:08,470 --> 00:15:11,005
Quindi, questo è ancora visto nella raccolta qui,

188
00:15:11,005 --> 00:15:13,500
e il nuovo documento che abbiamo appena inserito qui.

189
00:15:13,500 --> 00:15:17,179
Questo documento è visto proprio sotto quello qui,

190
00:15:17,179 --> 00:15:20,510
ma si noti che questi due hanno due ID diversi.

191
00:15:20,510 --> 00:15:25,030
Questo ID corrisponde all'ID del documento appena inserito.

192
00:15:25,030 --> 00:15:28,455
Quindi, questo è un residuo dell'esercizio precedente.

193
00:15:28,455 --> 00:15:32,765
Dopo questo, ovviamente lasciamo cadere la collezione in modo che

194
00:15:32,765 --> 00:15:38,060
tutto questo insieme di documenti e la collezione di piatti verrà rimosso dal nostro database.

195
00:15:38,060 --> 00:15:41,060
Quindi, ora il nostro database sarà pulito e vuoto.

196
00:15:41,060 --> 00:15:44,930
Quindi, questo dimostra a voi come possiamo usare

197
00:15:44,930 --> 00:15:52,900
il driver MongoDB per comunicare dalla nostra applicazione nodo con il server.

198
00:15:52,900 --> 00:15:55,330
Ora che abbiamo la nostra applicazione,

199
00:15:55,330 --> 00:16:01,000
lasciami introdurre un file.gitignore

200
00:16:01,000 --> 00:16:06,720
qui e poi inserire i moduli del nodo in.gitignore,

201
00:16:06,720 --> 00:16:10,540
e capisci rapidamente perché sto facendo questo.

202
00:16:10,540 --> 00:16:16,595
Poi, torneremo indietro e inizializzeremo il repository Git e poi faremo un commit git.

203
00:16:16,595 --> 00:16:18,590
Tornando al terminale,

204
00:16:18,590 --> 00:16:21,505
lasciami inizializzare il repository Git,

205
00:16:21,505 --> 00:16:31,460
e poi, controlliamo lo stato Git e vedi che ci sono alcuni file non impegnati.

206
00:16:31,460 --> 00:16:37,204
Quindi lasciami controllare e poi fare un commit git con il messaggio,

207
00:16:37,204 --> 00:16:46,450
Node MongoDB Esempio uno.

208
00:16:46,450 --> 00:16:49,305
Questa è la parte uno dell'esercizio,

209
00:16:49,305 --> 00:16:54,020
quindi controlleremo solo gli elementi nel nostro repository git.

210
00:16:54,020 --> 00:16:56,900
Questo completa questo esercizio.

211
00:16:56,900 --> 00:17:01,760
In questo esercizio, abbiamo visto come installiamo il modulo nodo,

212
00:17:01,760 --> 00:17:04,365
il driver MongoDB, quindi,

213
00:17:04,365 --> 00:17:07,835
siamo stati in grado di comunicare con il nostro server MongoDB dall'interno della

214
00:17:07,835 --> 00:17:12,740
nostra applicazione nodo utilizzando i metodi che sono forniti dal driver MongoDB.

215
00:17:12,740 --> 00:17:17,840
Continueremo con questo esercizio nella prossima parte

216
00:17:17,840 --> 00:17:24,380
dell'esercizio dove esploreremo alcuni altri metodi del driver MongoDB.