1
00:00:03,680 --> 00:00:07,560
In questo esercizio continueremo a lavorare

2
00:00:07,560 --> 00:00:11,190
sul server Mangoose del nodo sviluppato nell'esercizio precedente.

3
00:00:11,190 --> 00:00:13,770
Faremo un'altra variante di questo.

4
00:00:13,770 --> 00:00:19,190
Inoltre, vedremo anche come Mongoose supporta i documenti secondari,

5
00:00:19,190 --> 00:00:22,760
e questo ci permette di memorizzare un documento all'interno di

6
00:00:22,760 --> 00:00:26,860
un documento per memorizzare informazioni aggiuntive.

7
00:00:26,860 --> 00:00:31,055
Diamo un'occhiata a questo nell'esercizio successivo.

8
00:00:31,055 --> 00:00:36,905
Continuando con l'esempio su cui abbiamo lavorato, ora,

9
00:00:36,905 --> 00:00:39,680
nel file index.js,

10
00:00:39,680 --> 00:00:46,040
ora vedremo un nuovo modo di creare un piatto e aggiungerlo alla nostra applicazione.

11
00:00:46,040 --> 00:00:51,590
Così, in precedenza avevamo fatto var NewDish e piatti e definire il piatto.

12
00:00:51,590 --> 00:00:57,980
Ora, in questo caso useremo un nuovo metodo chiamato piatti create che prende,

13
00:00:57,980 --> 00:01:05,950
come parametro, il NewDish per creare e poi lo salva nella nostra applicazione.

14
00:01:05,950 --> 00:01:11,165
Quindi, invece di fare questo salvataggio NewDish,

15
00:01:11,165 --> 00:01:18,550
possiamo semplicemente rimuoverlo e trattare direttamente con i piatti creare il metodo qui.

16
00:01:18,550 --> 00:01:22,850
Così, il metodo di creazione piatti prenderà come parametro

17
00:01:22,850 --> 00:01:27,320
un nuovo documento che deve essere memorizzato nel nostro database,

18
00:01:27,320 --> 00:01:31,355
e quindi crea e aggiunge il documento al database.

19
00:01:31,355 --> 00:01:35,285
Successivamente, possiamo continuare con il resto dell'esercizio.

20
00:01:35,285 --> 00:01:40,390
Questa piccola modifica mostrerà

21
00:01:40,390 --> 00:01:45,790
che la stessa applicazione viene eseguita esattamente allo stesso modo di prima.

22
00:01:45,790 --> 00:01:47,365
Quindi, con questo cambiamento,

23
00:01:47,365 --> 00:01:50,080
lasciami solo cambiare il rientro

24
00:01:50,080 --> 00:01:56,370
qui in modo che il concatenamento dei metodi allora sia molto chiaro.

25
00:01:56,370 --> 00:02:01,130
Quindi, prima facciamo un piatto creato che restituirà una promessa,

26
00:02:01,130 --> 00:02:04,300
e poi cambieremo all'allora e poi eseguiremo

27
00:02:04,300 --> 00:02:10,255
i passaggi rimanenti sul piatto creato.

28
00:02:10,255 --> 00:02:15,905
Salviamo le modifiche e poi andiamo a dare un'occhiata a questa versione del nostro server.

29
00:02:15,905 --> 00:02:17,475
Andando al terminale,

30
00:02:17,475 --> 00:02:20,675
ancora una volta, eseguendo l'applicazione,

31
00:02:20,675 --> 00:02:28,040
vediamo che creerà esattamente lo stesso della precedente variante del server.

32
00:02:28,040 --> 00:02:33,290
Quindi, stiamo creando un nuovo piatto qui e poi inserendolo

33
00:02:33,290 --> 00:02:36,800
nel database e in seguito

34
00:02:36,800 --> 00:02:40,760
stiamo recuperando quel piatto e poi stampando sullo schermo.

35
00:02:40,760 --> 00:02:43,610
Con questo cambiamento, questo è un buon momento per noi per fare

36
00:02:43,610 --> 00:02:47,795
un commit git con il messaggio Mongoose parte due.

37
00:02:47,795 --> 00:02:57,450
Quindi, controlliamo lo stato git e quindi aggiungiamo il file al repository,

38
00:02:57,450 --> 00:03:06,390
quindi facciamo un commit git con il messaggio Mongoose parte due.

39
00:03:06,390 --> 00:03:08,800
Continuando con l'esercizio,

40
00:03:08,800 --> 00:03:13,910
nel passaggio successivo andremo ad aggiungere un sottodocumento

41
00:03:13,910 --> 00:03:19,385
al documento e vedere come i documenti secondari possono essere memorizzati nel nostro database.

42
00:03:19,385 --> 00:03:22,385
Quindi, andando al file dishes.js,

43
00:03:22,385 --> 00:03:30,135
aggiungerò un altro schema nel mio file dishes.js chiamato

44
00:03:30,135 --> 00:03:37,360
come commento Schema e

45
00:03:37,360 --> 00:03:42,230
quindi definirlo come nuovo schema.

46
00:03:42,320 --> 00:03:44,880
In questo schema di commento,

47
00:03:44,880 --> 00:03:46,895
come ti saresti già previsto,

48
00:03:46,895 --> 00:03:51,360
useremo questo per memorizzare i commenti sul piatto.

49
00:03:51,360 --> 00:03:56,380
Quindi, i commenti conterranno un campo di valutazione che

50
00:03:56,380 --> 00:04:02,930
è del numero di tipo,

51
00:04:02,930 --> 00:04:07,250
e il suo valore minimo è uno,

52
00:04:07,250 --> 00:04:15,290
il valore massimo è cinque e richiesto è vero.

53
00:04:15,290 --> 00:04:20,120
Quindi, si può vedere che quando si utilizza un campo con il numero di tipo,

54
00:04:20,120 --> 00:04:26,085
è possibile specificare i limiti per esso se si sceglie di farlo.

55
00:04:26,085 --> 00:04:35,640
Quindi il campo successivo è un campo di commento che sarebbe della stringa di tipo.

56
00:04:35,640 --> 00:04:41,780
Quindi, questo memorizza un messaggio e quindi richiesto

57
00:04:41,780 --> 00:04:49,300
è vero e poi aggiungeremo anche un altro campo chiamato autore,

58
00:04:51,220 --> 00:05:01,120
che è della stringa di tipo e richiesto è vero.

59
00:05:01,120 --> 00:05:07,600
Aggiungeremo anche il campo timestamp per questo,

60
00:05:07,600 --> 00:05:11,875
e impostarlo su true.

61
00:05:11,875 --> 00:05:14,570
Quindi, per ogni commento che viene aggiunto,

62
00:05:14,570 --> 00:05:17,570
memorizzeremo anche il timestamp corrispondente.

63
00:05:17,570 --> 00:05:20,990
Quindi, ora che abbiamo dichiarato uno schema di commento,

64
00:05:20,990 --> 00:05:27,465
possiamo quindi andare avanti e modificare lo schema piatto per essere in grado di memorizzare i commenti.

65
00:05:27,465 --> 00:05:29,745
Quindi, all'interno dello schema dei piatti,

66
00:05:29,745 --> 00:05:37,370
possiamo aggiungere commenti

67
00:05:37,370 --> 00:05:44,750
che è una matrice dello schema di commento del tipo,

68
00:05:44,750 --> 00:05:49,705
quindi il che significa che ogni oggetto piatto,

69
00:05:49,705 --> 00:05:57,860
documento piatto può avere più commenti memorizzati all'interno di un array all'interno del documento piatto.

70
00:05:57,860 --> 00:06:04,830
Quindi, questo è il commento documenti diventa sotto-documenti all'interno di un documento piatto.

71
00:06:04,830 --> 00:06:08,524
Quindi, stiamo memorizzando tutti i commenti sul piatto all'interno

72
00:06:08,524 --> 00:06:13,765
del piatto stesso come una serie di documenti di commento.

73
00:06:13,765 --> 00:06:20,825
Quindi, questo è l'uso del sottodocumento in Mongoose.

74
00:06:20,825 --> 00:06:28,395
Dopo questo, andiamo al file index.js e quindi modificare il nostro file index.js.

75
00:06:28,395 --> 00:06:32,640
Qui dentro, creano il piatto proprio come prima.

76
00:06:32,640 --> 00:06:35,010
Quindi, dopo aver creato il piatto,

77
00:06:35,010 --> 00:06:38,715
quindi consoli registriamo il piatto.

78
00:06:38,715 --> 00:06:43,080
Successivamente, aggiorneremo il piatto.

79
00:06:43,080 --> 00:06:49,925
Quindi, diremo piatti trovare per ID e aggiornare.

80
00:06:49,925 --> 00:06:55,345
Quindi, stiamo andando a modificare il piatto che abbiamo appena inserito nel passaggio precedente.

81
00:06:55,345 --> 00:06:58,690
Quindi, diremo, «Trova per ID e aggiorna».

82
00:06:58,690 --> 00:07:01,930
E noi stiamo andando a rifornire.

83
00:07:01,930 --> 00:07:05,305
In questo richiede due parametri,

84
00:07:05,305 --> 00:07:10,045
il primo parametro è il piatto.

85
00:07:10,045 --> 00:07:15,205
Ora, questo piatto. _id naturalmente si riferisce a questo piatto che abbiamo appena inserito,

86
00:07:15,205 --> 00:07:19,895
e poi abbiamo intenzione di modificare lo stesso piatto nel passaggio successivo.

87
00:07:19,895 --> 00:07:22,420
Quindi diremo: «Piatto. _id.» E poi,

88
00:07:22,420 --> 00:07:34,610
tra parentesi, specifichiamo $ set, descrizione,

89
00:07:36,600 --> 00:07:45,580
test aggiornato e nuovo vero.

90
00:07:45,580 --> 00:07:49,240
Quindi, questo, stiamo modificando il piatto che abbiamo

91
00:07:49,240 --> 00:07:54,865
appena inserito aggiornando la sua descrizione lì.

92
00:07:54,865 --> 00:07:58,735
Ora, questo deve essere racchiuso all'interno.

93
00:07:58,735 --> 00:08:01,310
Questa seconda bandiera che stiamo fornendo qui,

94
00:08:01,310 --> 00:08:03,985
nuovo colon uguale a true,

95
00:08:03,985 --> 00:08:07,895
significa che una volta completato l'aggiornamento del piatto,

96
00:08:07,895 --> 00:08:11,075
allora questo restituirà il piatto,

97
00:08:11,075 --> 00:08:14,530
piatto aggiornato a noi.

98
00:08:14,530 --> 00:08:20,350
Quindi, questa è la ragione per usare questa bandiera qui, diciamo, nuova vera.

99
00:08:20,350 --> 00:08:25,275
Quindi, questo piatto verrà restituito nel passaggio successivo.

100
00:08:25,275 --> 00:08:32,905
Quindi, prenderemo quel piatto e poi stamperemo quel piatto.

101
00:08:32,905 --> 00:08:34,540
Quindi, nel prossimo passo,

102
00:08:34,540 --> 00:08:41,845
modificheremo questo e diremo: «Questo, poi piatto».

103
00:08:41,845 --> 00:08:45,790
E poi, faremo un registro consolle di piatto.

104
00:08:45,790 --> 00:08:55,060
Poi dopo questo, inseriremo un commento nel piatto.

105
00:08:55,060 --> 00:09:00,405
Quindi, diremo, «dish.comments.push.»

106
00:09:00,405 --> 00:09:04,420
Ricordiamo che i commenti sono un campo all'interno del piatto.

107
00:09:04,420 --> 00:09:06,930
Quindi, tornando allo schema,

108
00:09:06,930 --> 00:09:12,685
vediamo che questo commento è una matrice del tipo CommentSchema.

109
00:09:12,685 --> 00:09:16,360
Quindi, il che significa che possiamo spingere un elemento in questo array.

110
00:09:16,360 --> 00:09:17,700
Quindi, tornando qui

111
00:09:17,700 --> 00:09:21,180
, diremo: «I commenti del piatto spingono».

112
00:09:21,180 --> 00:09:27,380
E poi, inseriremo un documento di commento nel piatto qui.

113
00:09:27,380 --> 00:09:31,415
Quindi, dirò: «I commenti del piatto spingono».

114
00:09:31,415 --> 00:09:33,990
E specificare i campi qui.

115
00:09:33,990 --> 00:10:00,540
Quindi, diremo, «Valutazione cinque, commento e autore».

116
00:10:07,890 --> 00:10:17,155
E così, questo spingerà questo commento nel campo dei commenti di questo piatto specifico.

117
00:10:17,155 --> 00:10:20,065
Quindi, ora che abbiamo modificato il piatto,

118
00:10:20,065 --> 00:10:24,655
il prossimo passo che faremo è quello di,

119
00:10:24,655 --> 00:10:30,030
lasciami chiudere questo e poi metterlo dentro, poi lì.

120
00:10:30,030 --> 00:10:32,400
Tornero' e sistemero' tutto tra poco.

121
00:10:32,400 --> 00:10:34,555
Quindi, ora che abbiamo modificato il piatto,

122
00:10:34,555 --> 00:10:37,630
dobbiamo salvare il piatto.

123
00:10:37,630 --> 00:10:42,430
Quindi diremo: «Ritorna il piatto sicuro».

124
00:10:42,430 --> 00:10:44,280
Quindi, in questo passaggio,

125
00:10:44,280 --> 00:10:47,520
stiamo inserendo un commento nel piatto,

126
00:10:47,520 --> 00:10:51,055
il piatto che abbiamo appena creato e aggiornato,

127
00:10:51,055 --> 00:10:55,360
e quindi stiamo salvando quel commento;

128
00:10:55,360 --> 00:11:00,350
e poi, questo restituirà il piatto.

129
00:11:00,350 --> 00:11:07,480
E quando il piatto viene restituito nella prossima richiamata,

130
00:11:07,480 --> 00:11:15,160
ho intenzione di dire, «Consolle log dish».

131
00:11:15,160 --> 00:11:16,240
E poi, dopo

132
00:11:16,240 --> 00:11:17,920
, diremo: «Ritorna».

133
00:11:17,920 --> 00:11:22,435
Quindi, con questo, abbiamo modificato il nostro file index.js.

134
00:11:22,435 --> 00:11:27,265
Salviamo le modifiche e guardiamo questa applicazione.

135
00:11:27,265 --> 00:11:29,135
Andando al terminale,

136
00:11:29,135 --> 00:11:34,770
eseguiamo npm start e poi vediamo il valore risultante qui.

137
00:11:34,770 --> 00:11:38,570
Quindi, tornando indietro, vediamo che nel primo passo,

138
00:11:38,570 --> 00:11:45,430
abbiamo creato questo piatto qui con il nome e la descrizione come abbiamo dato in precedenza.

139
00:11:45,430 --> 00:11:49,675
E poi, una volta creato il piatto,

140
00:11:49,675 --> 00:11:50,980
nel secondo passaggio,

141
00:11:50,980 --> 00:11:55,730
abbiamo aggiornato il piatto e poi stampato la versione aggiornata del piatto.

142
00:11:55,730 --> 00:11:59,325
Quindi, la versione aggiornata del piatto è stampata proprio lì.

143
00:11:59,325 --> 00:12:03,940
E puoi vedere che la descrizione è stata aggiornata dal caso precedente,

144
00:12:03,940 --> 00:12:10,210
ma l'id rimane esattamente lo stesso del piatto che abbiamo creato in precedenza.

145
00:12:10,210 --> 00:12:11,720
E il campo dei commenti,

146
00:12:11,720 --> 00:12:12,875
come puoi vedere qui,

147
00:12:12,875 --> 00:12:15,150
è un array vuoto e l'affumicato.

148
00:12:15,150 --> 00:12:22,555
In terzo passo, spingiamo il commento nel nostro piatto qui;

149
00:12:22,555 --> 00:12:25,560
e poi così, questo particolare commento che

150
00:12:25,560 --> 00:12:28,880
abbiamo aggiunto è stato aggiunto in questo array commenti.

151
00:12:28,880 --> 00:12:32,475
Quindi, si può vedere che il commento è racchiuso qui,

152
00:12:32,475 --> 00:12:39,440
e questo è il piatto aggiornato che è stato ora stampato sullo schermo qui.

153
00:12:39,440 --> 00:12:45,270
Quindi, puoi vedere che abbiamo fatto diversi passaggi uno dopo l'altro con il nostro piatto.

154
00:12:45,270 --> 00:12:46,840
Prima abbiamo creato il piatto,

155
00:12:46,840 --> 00:12:48,460
poi abbiamo aggiornato il piatto,

156
00:12:48,460 --> 00:12:51,340
poi abbiamo inserito un commento nel piatto,

157
00:12:51,340 --> 00:12:55,745
che è un sottodocumento all'interno del documento piatto;

158
00:12:55,745 --> 00:12:59,035
e poi, abbiamo stampato il risultato a voi.

159
00:12:59,035 --> 00:13:02,390
Con questo, completiamo questo esercizio.

160
00:13:02,390 --> 00:13:06,500
In questo esercizio, abbiamo visto come possiamo, in

161
00:13:06,500 --> 00:13:10,930
primo luogo, creare un piatto utilizzando piatti creare,

162
00:13:10,930 --> 00:13:14,520
poi abbiamo visto l'uso di sotto-documenti: lì,

163
00:13:14,520 --> 00:13:18,060
abbiamo definito uno schema all'interno del

164
00:13:18,060 --> 00:13:21,720
file dishes.js e quindi utilizzare lo schema di commento che abbiamo

165
00:13:21,720 --> 00:13:29,130
definito e poi definito il campo nello schema piatti come matrice del tipo CommentSchema.

166
00:13:29,130 --> 00:13:32,810
E poi, nel file index.js,

167
00:13:32,810 --> 00:13:35,445
siamo stati in grado di creare un piatto,

168
00:13:35,445 --> 00:13:38,210
aggiornare il piatto e anche spingere

169
00:13:38,210 --> 00:13:44,140
un documento di commento nel piatto e quindi salvare le modifiche qui.

170
00:13:44,140 --> 00:13:46,480
Con questo, completiamo questo esercizio.

171
00:13:46,480 --> 00:13:54,170
Questo è un buon momento per voi per fare un Git Kermit con il messaggio, «Mangusta parte tre.»