1
00:00:03,710 --> 00:00:10,380
Ora che abbiamo avuto una rapida panoramica di Mongoose ODM e

2
00:00:10,380 --> 00:00:16,710
come Mongoose porta schemi per strutturare i documenti che memorizziamo nel nostro MongoDB,

3
00:00:16,710 --> 00:00:19,830
diamo un'occhiata a come facciamo uso

4
00:00:19,830 --> 00:00:27,000
del modulo nodo Mongoose e quindi incorporarlo nella nostra applicazione nodo.

5
00:00:27,000 --> 00:00:31,065
Quindi utilizzare Mongoose per comunicare con

6
00:00:31,065 --> 00:00:35,760
il nostro server MongoDB e quindi memorizzare e recuperare

7
00:00:35,760 --> 00:00:41,355
documenti con informazioni sulla struttura nei documenti.

8
00:00:41,355 --> 00:00:44,830
Per iniziare a questo esercizio,

9
00:00:44,830 --> 00:00:48,080
vai in una posizione comoda sul tuo computer.

10
00:00:48,080 --> 00:00:52,760
Quindi, eccomi nella cartella Node JS in cui ho memorizzato

11
00:00:52,760 --> 00:00:57,020
tutti gli esempi di questo corso e poi

12
00:00:57,020 --> 00:01:02,210
creerò una nuova cartella denominata nodo Mongoose.

13
00:01:02,210 --> 00:01:10,320
Questo è dove creeremo l'applicazione nodo utilizzando Mongoose prossimo.

14
00:01:10,320 --> 00:01:12,900
Nel terminale o nella finestra di comando,

15
00:01:12,900 --> 00:01:19,080
passare alla cartella Mongoose nodo e quindi inizializzare un'applicazione nodo lì.

16
00:01:19,080 --> 00:01:22,385
Quindi, lasciami digitare npm init e quindi

17
00:01:22,385 --> 00:01:26,359
inizializzare l'applicazione del nodo e poi chiamerei l'applicazione

18
00:01:26,359 --> 00:01:34,174
come node-mangusta e il punto di ingresso è index.js git history,

19
00:01:34,174 --> 00:01:42,590
parole chiave, autore e licenza e diremo okay.

20
00:01:42,590 --> 00:01:49,574
Una volta creato il file package.json del nodo,

21
00:01:49,574 --> 00:01:54,500
apri il progetto nell'editor di testo a tua scelta.

22
00:01:54,500 --> 00:02:02,809
Quindi, qui ho il mio progetto aperto in Visual Studio.

23
00:02:02,809 --> 00:02:05,915
Lasciami andare nel file package.json e quindi aggiungere

24
00:02:05,915 --> 00:02:14,750
lo script di avvio e poi

25
00:02:14,750 --> 00:02:24,160
diremo indice di avvio del nodo come al solito ogni volta che iniziamo con una nuova applicazione nodo.

26
00:02:24,160 --> 00:02:29,945
Quindi, andando al terminale o alla finestra di comando, installiamo Mongoose.

27
00:02:29,945 --> 00:02:37,290
Quindi, al prompt digitare npm installa Mongoose, salva.

28
00:02:39,470 --> 00:02:45,570
Che al momento è Mongoose 5.1.7.

29
00:02:45,570 --> 00:02:49,760
Quindi, queste sono le versioni che userò in questo corso.

30
00:02:49,760 --> 00:02:54,920
Quindi andando alla mia applicazione nell'editor.

31
00:02:54,920 --> 00:03:01,430
Permettetemi di creare una sottocartella nel progetto chiamato come Models.

32
00:03:01,430 --> 00:03:07,320
Quindi, questo è dove ho intenzione di memorizzare tutti i modelli per la mia applicazione.

33
00:03:07,340 --> 00:03:10,230
Nella cartella dei modelli,

34
00:03:10,230 --> 00:03:15,170
permettetemi di creare un nuovo file denominato dishes.js.

35
00:03:15,170 --> 00:03:19,535
Quindi, questo è dove ho intenzione di creare lo schema e il modello

36
00:03:19,535 --> 00:03:24,680
per i miei piatti documento che ho intenzione di memorizzare,

37
00:03:24,680 --> 00:03:29,770
la collezione di piatti che memorizza i documenti per ogni piatto.

38
00:03:29,770 --> 00:03:36,730
Quindi, proprio lì, fammi importare prima Mangusta.

39
00:03:39,320 --> 00:03:47,880
Quindi, avremo bisogno di Mongoose in questo file e poi dire

40
00:03:47,880 --> 00:03:57,940
const schema è Mongoose schema.

41
00:03:59,420 --> 00:04:03,510
Quindi, creeremo lo schema qui.

42
00:04:03,510 --> 00:04:13,845
Quindi, diremo const DishSchema nuovo schema.

43
00:04:13,845 --> 00:04:19,590
Quindi, questo è dove definisco lo schema per il mio piatto.

44
00:04:20,830 --> 00:04:27,270
All' interno di questo schema, permettetemi di definire i vari valori.

45
00:04:27,270 --> 00:04:29,830
Quindi, dirò nome,

46
00:04:29,890 --> 00:04:34,405
che è il tipo String.

47
00:04:34,405 --> 00:04:41,480
Quindi, questo è il tipo di schema e quindi questo dichiarerei come richiesto.

48
00:04:41,480 --> 00:04:43,460
Quindi, dirò vero.

49
00:04:43,460 --> 00:04:52,790
Quindi, ogni documento avrà il nome come campo obbligatorio lì e poi

50
00:04:52,790 --> 00:04:57,185
dichiarerò anche questo come significato univoco che

51
00:04:57,185 --> 00:05:02,545
nessun documento dovrebbe avere lo stesso campo nome in là.

52
00:05:02,545 --> 00:05:08,230
Quindi, questo è il primo campo nel mio documento.

53
00:05:10,190 --> 00:05:19,440
Quindi, includeremo anche un altro campo chiamato come, descrizione.

54
00:05:19,440 --> 00:05:29,205
La descrizione è della stringa di tipo e richiesto true.

55
00:05:29,205 --> 00:05:35,165
Inoltre, possiamo avere Mongoose inserire automaticamente

56
00:05:35,165 --> 00:05:41,639
timestamp nel nostro modello.

57
00:05:41,639 --> 00:05:50,340
Quindi, proprio lì possiamo semplicemente impostare i timestamp della bandiera: vero.

58
00:05:50,340 --> 00:05:55,810
Quindi, questo aggiungerà automaticamente il creato a e aggiornato a,

59
00:05:55,810 --> 00:06:01,340
due timestamp in ogni documento che è memorizzato

60
00:06:01,340 --> 00:06:07,235
nella nostra applicazione e aggiornerà automaticamente questi valori.

61
00:06:07,235 --> 00:06:11,330
Ogni volta che aggiorniamo il documento e il creato a verrà automaticamente

62
00:06:11,330 --> 00:06:15,390
inizializzato quando il documento è il primo creatore di questo tempo.

63
00:06:15,390 --> 00:06:22,680
Dopo questo, diremo piatti var.

64
00:06:22,680 --> 00:06:24,549
Quindi, dato lo schema,

65
00:06:24,549 --> 00:06:29,605
ora stiamo andando a costruire il modello da questo schema.

66
00:06:29,605 --> 00:06:35,215
Quindi, diremo modello Mangusta e piatto,

67
00:06:35,215 --> 00:06:43,570
e questo sta per essere utilizzando lo schema piatto che abbiamo appena dichiarato in precedenza.

68
00:06:43,570 --> 00:06:48,590
Quindi esporteremo

69
00:06:48,590 --> 00:06:55,725
questo modello da questo file qui.

70
00:06:55,725 --> 00:06:58,410
Quindi, diremo piatti di esportazione del modulo.

71
00:06:58,410 --> 00:07:00,545
Così, ora abbiamo costruito

72
00:07:00,545 --> 00:07:05,780
lo schema Mongoose e il modello corrispondente e il modello è ora esportato da qui.

73
00:07:05,780 --> 00:07:10,580
Quindi, questo può essere importato nella nostra applicazione e utilizzato.

74
00:07:10,580 --> 00:07:13,345
Quindi, all'interno della nostra cartella di progetto,

75
00:07:13,345 --> 00:07:20,415
lasciami creare un nuovo file chiamato index.js.

76
00:07:20,415 --> 00:07:23,265
Nel file index.js,

77
00:07:23,265 --> 00:07:31,450
permettimi prima di richiedere Mongoose,

78
00:07:31,820 --> 00:07:34,900
e poi dopo questo possiamo dire

79
00:07:34,900 --> 00:07:44,970
const Piatti richiedono piatti di modelli.

80
00:07:44,970 --> 00:07:49,210
Perché abbiamo già creato il modello Piatti

81
00:07:49,210 --> 00:07:55,740
nel file piatti modelli lì e quindi lo stiamo richiedendo qui.

82
00:07:55,740 --> 00:08:02,975
Ora, per stabilire la connessione al server Mongo,

83
00:08:02,975 --> 00:08:09,330
diremo const URL mongodb.

84
00:08:09,840 --> 00:08:17,110
Localhost 27017, Confusione.

85
00:08:17,110 --> 00:08:25,760
Quindi, questo database è quello che ci collegheremo dalla nostra applicazione e

86
00:08:25,760 --> 00:08:35,125
poi dopo che possiamo stabilire la connessione dicendo const connect Mongoose.

87
00:08:35,125 --> 00:08:38,195
Mongoose supporta questo metodo di connessione,

88
00:08:38,195 --> 00:08:41,695
che accetta l'URL come primo parametro.

89
00:08:41,695 --> 00:08:44,250
Quindi, una volta stabilito questo,

90
00:08:44,250 --> 00:08:49,470
allora diciamo semplicemente collegare poi.

91
00:08:49,470 --> 00:08:52,280
Si noti che dal momento che stiamo già usando le promesse,

92
00:08:52,280 --> 00:08:57,680
possiamo solo dire connetti poi e poi questo prenderà

93
00:08:57,680 --> 00:09:03,774
una funzione come parametro

94
00:09:03,774 --> 00:09:10,175
e dentro qui possiamo ora connetterci al database.

95
00:09:10,175 --> 00:09:13,550
Così ora una volta stabilita questa connessione,

96
00:09:13,550 --> 00:09:17,800
lasciami fare un registro console

97
00:09:17,800 --> 00:09:26,060
dicendo collegato correttamente al server,

98
00:09:26,100 --> 00:09:36,355
e qui posso creare un nuovo piatto dicendo var

99
00:09:36,355 --> 00:09:45,560
nuovo piatto e poi Piatti e dentro qui posso specificare un documento così sto creando

100
00:09:45,560 --> 00:09:50,170
un nuovo piatto di questo tipo e poi così qui

101
00:09:50,170 --> 00:09:55,510
Specificherò i due campi che sono obbligatori.

102
00:09:55,510 --> 00:09:57,920
Quindi dirò nome,

103
00:10:07,950 --> 00:10:16,390
descrizione e così è come si creerebbe un nuovo piatto e poi una volta creato

104
00:10:16,390 --> 00:10:24,910
un nuovo piatto dal modello diremo semplicemente nuovo piatto salvare.

105
00:10:24,910 --> 00:10:29,760
Il metodo di salvataggio farà sì che questo valore Dish venga

106
00:10:29,760 --> 00:10:35,060
salvato e poi come ci si aspetta restituirà una promessa e

107
00:10:35,060 --> 00:10:45,165
poi qui otterremo il valore Dish come richiamo lì e poi,

108
00:10:45,165 --> 00:10:54,940
posso semplicemente registrare il valore Dish qui e poi diremo

109
00:10:54,940 --> 00:11:00,915
Piatti trovare e così troveremo

110
00:11:00,915 --> 00:11:07,090
tutti i Piatti e poi dire exec.

111
00:11:07,090 --> 00:11:10,255
L' exec si assicurerà che questo venga

112
00:11:10,255 --> 00:11:15,250
eseguito e che restituisca una promessa e in modo che la promessa

113
00:11:15,250 --> 00:11:19,660
venga restituita in modo che possa quindi

114
00:11:19,660 --> 00:11:27,040
concatenare il metodo a quelli rimanenti.

115
00:11:27,040 --> 00:11:33,975
Quindi vedi come sto usando le promesse e poi sto invocando il metodo precedente in modo che questo

116
00:11:33,975 --> 00:11:41,395
trovi tutti i piatti all'interno del mio database,

117
00:11:41,395 --> 00:11:45,905
nella collezione Piatti e quindi me li rende disponibili.

118
00:11:45,905 --> 00:11:55,550
Quindi, quando ottengo i piatti, posso semplicemente consolare il registro dei piatti solo per vedere cosa viene

119
00:11:55,550 --> 00:11:58,790
restituito e questo ovviamente in questa fase dovrebbe

120
00:11:58,790 --> 00:12:02,710
restituire questo singolo piatto che ho inserito nella

121
00:12:02,710 --> 00:12:10,940
mia collezione Piatti e poi diremo di

122
00:12:11,010 --> 00:12:15,550
ritorno Piatti rimuovi con

123
00:12:15,550 --> 00:12:19,930
un oggetto JavaScript vuoto che rimuoverà tutti i piatti

124
00:12:19,930 --> 00:12:24,384
dal database e restituirà la chiusura della

125
00:12:24,384 --> 00:12:31,790
connessione mangusta che chiude la connessione al database.

126
00:12:35,040 --> 00:12:38,830
E cattura qualsiasi errore a questo punto.

127
00:12:38,830 --> 00:12:49,430
Quindi useremo il catch e poi il log della console.

128
00:12:50,600 --> 00:12:57,820
Questo è tutto. Quindi quello che stiamo facendo qui è che stiamo creando il nuovo questo piatto e poi stiamo

129
00:12:57,820 --> 00:13:04,255
salvando il piatto, quindi stiamo trovando tutti i piatti della collezione.

130
00:13:04,255 --> 00:13:06,740
Questo è tutto. Stiamo usando le promesse qui,

131
00:13:06,740 --> 00:13:10,435
quindi abbiamo incatenato tutte le tane qui dentro. Questo è tutto.

132
00:13:10,435 --> 00:13:15,595
Salviamo le modifiche e quindi vedere questa applicazione in esecuzione.

133
00:13:15,595 --> 00:13:17,455
Vai al terminale,

134
00:13:17,455 --> 00:13:21,505
al prompt tipo npm start e

135
00:13:21,505 --> 00:13:25,735
vedrai che la mia applicazione nodo viene eseguita e poi mostra,

136
00:13:25,735 --> 00:13:33,110
prima, che ha creato questo particolare Dish.

137
00:13:33,110 --> 00:13:37,285
Nota in particolare, che questi due campi,

138
00:13:37,285 --> 00:13:39,365
aggiornati e creati a,

139
00:13:39,365 --> 00:13:43,465
questi due timestamp sono stati aggiunti automaticamente

140
00:13:43,465 --> 00:13:47,790
nel Dish qui e così puoi vedere che il creato a e

141
00:13:47,790 --> 00:13:51,630
aggiornato a timestamp sono esattamente gli stessi al momento e

142
00:13:51,630 --> 00:13:57,235
quindi l'ID viene anche aggiunto automaticamente in.

143
00:13:57,235 --> 00:14:03,210
Nella fase successiva stiamo stampando tutti i piatti che sono stati recuperati e così si

144
00:14:03,210 --> 00:14:10,340
può vedere che questo singolo piatto è nella collezione, collezione

145
00:14:10,340 --> 00:14:15,935
Piatti, e questo è ciò che viene stampato sullo schermo qui.

146
00:14:15,935 --> 00:14:25,660
Inizializziamo ora il repository Git e poi impostiamo il file gitignore ottenuto

147
00:14:25,660 --> 00:14:35,125
quindi andando all'editor quindi creiamo il file.gitignore e quindi aggiungiamo

148
00:14:35,125 --> 00:14:40,240
i moduli nodo al file gitignore e salviamo le modifiche e

149
00:14:40,240 --> 00:14:45,325
poi tornando al prompt fammi

150
00:14:45,325 --> 00:14:48,550
digitare git status e vediamo che

151
00:14:48,550 --> 00:14:51,955
abbiamo questi file che non sono stati controllati, quindi diremo

152
00:14:51,955 --> 00:14:56,545
git add e poi git

153
00:14:56,545 --> 00:15:04,535
commit il messaggio Mongoose Part One.

154
00:15:04,535 --> 00:15:08,110
Con questo completiamo questo esercizio.

155
00:15:08,110 --> 00:15:14,300
In questo esercizio abbiamo visto quanto sia facile impostare un'applicazione nodo con

156
00:15:14,300 --> 00:15:21,335
mangusta e connettersi al nostro server MongoDB e quindi interagire con esso.

157
00:15:21,335 --> 00:15:24,985
Ora poiché mangusta si basa sul server MongoDB,

158
00:15:24,985 --> 00:15:28,980
Mongoose può accedere a tutti i vari metodi

159
00:15:28,980 --> 00:15:32,690
supportati dal driver MongoDB anche.