In questo esercizio continueremo a lavorare
sul server Mangoose del nodo sviluppato nell'esercizio precedente.
Faremo un'altra variante di questo.
Inoltre, vedremo anche come Mongoose supporta i documenti secondari,
e questo ci permette di memorizzare un documento all'interno di
un documento per memorizzare informazioni aggiuntive.
Diamo un'occhiata a questo nell'esercizio successivo.
Continuando con l'esempio su cui abbiamo lavorato, ora,
nel file index.js,
ora vedremo un nuovo modo di creare un piatto e aggiungerlo alla nostra applicazione.
Così, in precedenza avevamo fatto var NewDish e piatti e definire il piatto.
Ora, in questo caso useremo un nuovo metodo chiamato piatti create che prende,
come parametro, il NewDish per creare e poi lo salva nella nostra applicazione.
Quindi, invece di fare questo salvataggio NewDish,
possiamo semplicemente rimuoverlo e trattare direttamente con i piatti creare il metodo qui.
Così, il metodo di creazione piatti prenderà come parametro
un nuovo documento che deve essere memorizzato nel nostro database,
e quindi crea e aggiunge il documento al database.
Successivamente, possiamo continuare con il resto dell'esercizio.
Questa piccola modifica mostrerà
che la stessa applicazione viene eseguita esattamente allo stesso modo di prima.
Quindi, con questo cambiamento,
lasciami solo cambiare il rientro
qui in modo che il concatenamento dei metodi allora sia molto chiaro.
Quindi, prima facciamo un piatto creato che restituirà una promessa,
e poi cambieremo all'allora e poi eseguiremo
i passaggi rimanenti sul piatto creato.
Salviamo le modifiche e poi andiamo a dare un'occhiata a questa versione del nostro server.
Andando al terminale,
ancora una volta, eseguendo l'applicazione,
vediamo che creerà esattamente lo stesso della precedente variante del server.
Quindi, stiamo creando un nuovo piatto qui e poi inserendolo
nel database e in seguito
stiamo recuperando quel piatto e poi stampando sullo schermo.
Con questo cambiamento, questo è un buon momento per noi per fare
un commit git con il messaggio Mongoose parte due.
Quindi, controlliamo lo stato git e quindi aggiungiamo il file al repository,
quindi facciamo un commit git con il messaggio Mongoose parte due.
Continuando con l'esercizio,
nel passaggio successivo andremo ad aggiungere un sottodocumento
al documento e vedere come i documenti secondari possono essere memorizzati nel nostro database.
Quindi, andando al file dishes.js,
aggiungerò un altro schema nel mio file dishes.js chiamato
come commento Schema e
quindi definirlo come nuovo schema.
In questo schema di commento,
come ti saresti già previsto,
useremo questo per memorizzare i commenti sul piatto.
Quindi, i commenti conterranno un campo di valutazione che
è del numero di tipo,
e il suo valore minimo è uno,
il valore massimo è cinque e richiesto è vero.
Quindi, si può vedere che quando si utilizza un campo con il numero di tipo,
è possibile specificare i limiti per esso se si sceglie di farlo.
Quindi il campo successivo è un campo di commento che sarebbe della stringa di tipo.
Quindi, questo memorizza un messaggio e quindi richiesto
è vero e poi aggiungeremo anche un altro campo chiamato autore,
che è della stringa di tipo e richiesto è vero.
Aggiungeremo anche il campo timestamp per questo,
e impostarlo su true.
Quindi, per ogni commento che viene aggiunto,
memorizzeremo anche il timestamp corrispondente.
Quindi, ora che abbiamo dichiarato uno schema di commento,
possiamo quindi andare avanti e modificare lo schema piatto per essere in grado di memorizzare i commenti.
Quindi, all'interno dello schema dei piatti,
possiamo aggiungere commenti
che è una matrice dello schema di commento del tipo,
quindi il che significa che ogni oggetto piatto,
documento piatto può avere più commenti memorizzati all'interno di un array all'interno del documento piatto.
Quindi, questo è il commento documenti diventa sotto-documenti all'interno di un documento piatto.
Quindi, stiamo memorizzando tutti i commenti sul piatto all'interno
del piatto stesso come una serie di documenti di commento.
Quindi, questo è l'uso del sottodocumento in Mongoose.
Dopo questo, andiamo al file index.js e quindi modificare il nostro file index.js.
Qui dentro, creano il piatto proprio come prima.
Quindi, dopo aver creato il piatto,
quindi consoli registriamo il piatto.
Successivamente, aggiorneremo il piatto.
Quindi, diremo piatti trovare per ID e aggiornare.
Quindi, stiamo andando a modificare il piatto che abbiamo appena inserito nel passaggio precedente.
Quindi, diremo, «Trova per ID e aggiorna».
E noi stiamo andando a rifornire.
In questo richiede due parametri,
il primo parametro è il piatto.
Ora, questo piatto. _id naturalmente si riferisce a questo piatto che abbiamo appena inserito,
e poi abbiamo intenzione di modificare lo stesso piatto nel passaggio successivo.
Quindi diremo: «Piatto. _id.» E poi,
tra parentesi, specifichiamo $ set, descrizione,
test aggiornato e nuovo vero.
Quindi, questo, stiamo modificando il piatto che abbiamo
appena inserito aggiornando la sua descrizione lì.
Ora, questo deve essere racchiuso all'interno.
Questa seconda bandiera che stiamo fornendo qui,
nuovo colon uguale a true,
significa che una volta completato l'aggiornamento del piatto,
allora questo restituirà il piatto,
piatto aggiornato a noi.
Quindi, questa è la ragione per usare questa bandiera qui, diciamo, nuova vera.
Quindi, questo piatto verrà restituito nel passaggio successivo.
Quindi, prenderemo quel piatto e poi stamperemo quel piatto.
Quindi, nel prossimo passo,
modificheremo questo e diremo: «Questo, poi piatto».
E poi, faremo un registro consolle di piatto.
Poi dopo questo, inseriremo un commento nel piatto.
Quindi, diremo, «dish.comments.push.»
Ricordiamo che i commenti sono un campo all'interno del piatto.
Quindi, tornando allo schema,
vediamo che questo commento è una matrice del tipo CommentSchema.
Quindi, il che significa che possiamo spingere un elemento in questo array.
Quindi, tornando qui
, diremo: «I commenti del piatto spingono».
E poi, inseriremo un documento di commento nel piatto qui.
Quindi, dirò: «I commenti del piatto spingono».
E specificare i campi qui.
Quindi, diremo, «Valutazione cinque, commento e autore».
E così, questo spingerà questo commento nel campo dei commenti di questo piatto specifico.
Quindi, ora che abbiamo modificato il piatto,
il prossimo passo che faremo è quello di,
lasciami chiudere questo e poi metterlo dentro, poi lì.
Tornero' e sistemero' tutto tra poco.
Quindi, ora che abbiamo modificato il piatto,
dobbiamo salvare il piatto.
Quindi diremo: «Ritorna il piatto sicuro».
Quindi, in questo passaggio,
stiamo inserendo un commento nel piatto,
il piatto che abbiamo appena creato e aggiornato,
e quindi stiamo salvando quel commento;
e poi, questo restituirà il piatto.
E quando il piatto viene restituito nella prossima richiamata,
ho intenzione di dire, «Consolle log dish».
E poi, dopo
, diremo: «Ritorna».
Quindi, con questo, abbiamo modificato il nostro file index.js.
Salviamo le modifiche e guardiamo questa applicazione.
Andando al terminale,
eseguiamo npm start e poi vediamo il valore risultante qui.
Quindi, tornando indietro, vediamo che nel primo passo,
abbiamo creato questo piatto qui con il nome e la descrizione come abbiamo dato in precedenza.
E poi, una volta creato il piatto,
nel secondo passaggio,
abbiamo aggiornato il piatto e poi stampato la versione aggiornata del piatto.
Quindi, la versione aggiornata del piatto è stampata proprio lì.
E puoi vedere che la descrizione è stata aggiornata dal caso precedente,
ma l'id rimane esattamente lo stesso del piatto che abbiamo creato in precedenza.
E il campo dei commenti,
come puoi vedere qui,
è un array vuoto e l'affumicato.
In terzo passo, spingiamo il commento nel nostro piatto qui;
e poi così, questo particolare commento che
abbiamo aggiunto è stato aggiunto in questo array commenti.
Quindi, si può vedere che il commento è racchiuso qui,
e questo è il piatto aggiornato che è stato ora stampato sullo schermo qui.
Quindi, puoi vedere che abbiamo fatto diversi passaggi uno dopo l'altro con il nostro piatto.
Prima abbiamo creato il piatto,
poi abbiamo aggiornato il piatto,
poi abbiamo inserito un commento nel piatto,
che è un sottodocumento all'interno del documento piatto;
e poi, abbiamo stampato il risultato a voi.
Con questo, completiamo questo esercizio.
In questo esercizio, abbiamo visto come possiamo, in
primo luogo, creare un piatto utilizzando piatti creare,
poi abbiamo visto l'uso di sotto-documenti: lì,
abbiamo definito uno schema all'interno del
file dishes.js e quindi utilizzare lo schema di commento che abbiamo
definito e poi definito il campo nello schema piatti come matrice del tipo CommentSchema.
E poi, nel file index.js,
siamo stati in grado di creare un piatto,
aggiornare il piatto e anche spingere
un documento di commento nel piatto e quindi salvare le modifiche qui.
Con questo, completiamo questo esercizio.
Questo è un buon momento per voi per fare un Git Kermit con il messaggio, «Mangusta parte tre.»