Dans cet exercice, nous allons continuer à travailler sur
le nœud serveur Mongoose que nous avons développé dans l'exercice précédent.
Nous ferons une autre variante de cela.
En outre, nous examinerons également comment Mongoose prend en charge les sous-documents,
ce qui nous permet de stocker un document dans
un document pour stocker des informations supplémentaires.
Regardons cela dans l'exercice suivant.
En continuant avec l'exemple sur lequel nous avons travaillé, maintenant,
dans le fichier index.js,
nous allons maintenant voir une nouvelle façon de créer un plat et de l'ajouter dans notre application.
Donc, plus tôt, nous avions fait var NewDish et plats et définir le plat.
Maintenant, dans ce cas, nous allons utiliser une nouvelle méthode appelée vaisselle créer qui prend,
comme paramètre, le NewDish à créer et ensuite l'enregistre dans notre application.
Donc, au lieu de faire cette sauvegarde NewDish,
nous pouvons simplement supprimer cela et traiter directement avec la méthode de création de plats ici.
Ainsi, la méthode de création de plats prendra comme paramètre
un nouveau document qui doit être stocké dans notre base de données,
puis crée et ajoute le document à la base de données.
Par la suite, nous pouvons continuer avec le reste de l'exercice.
Cette modification mineure montrera
que la même application fonctionne exactement de la même manière qu'avant.
Donc, avec ce changement,
permettez-moi juste de changer l'indentation
ici afin que le chaînage des méthodes then soit très clair.
Donc, nous faisons d'abord un plat créer qui retournera une promesse,
puis changer à l'puis puis nous allons effectuer
les étapes restantes sur le plat créé.
Sauvegardons les modifications, puis allons jeter un oeil à cette version de notre serveur.
Aller au terminal,
une fois de plus, en exécutant l'application,
nous voyons qu'il va créer exactement le même que la variation précédente du serveur.
Donc, nous créons un nouveau plat ici, puis l'insérons dans
la base de données et par la suite nous
récupérons ce plat et puis nous l'imprimons à l'écran.
Avec ce changement, c'est un bon moment pour nous de faire
un commit git avec le message Mongoose deuxième partie.
Donc, vérifions l'état git, puis ajoutons le fichier au dépôt,
puis faisons un commit git avec le message Mongoose deuxième partie.
En
poursuivant l'exercice, nous allons ajouter un sous-document au
document et voir comment les sous-documents peuvent être stockés dans notre base de données.
Donc,
en allant au fichier dishes.js, je vais ajouter un autre schéma dans mon fichier dishes.js appelé
comme schéma de commentaire
, puis définir ceci comme nouveau schéma.
Dans ce schéma de commentaire,
comme vous l'auriez déjà prévu,
nous allons l'utiliser pour stocker des commentaires sur le plat.
Ainsi, les commentaires contiendront un champ de notation qui
est du numéro de type,
et sa valeur minimale est un,
la valeur maximale est cinq et obligatoire est vrai.
Ainsi, vous pouvez voir que lorsque vous utilisez un champ avec le numéro de type,
vous pouvez spécifier les limites pour celui-ci si vous le souhaitez.
Ensuite, le champ suivant est un champ de commentaire qui serait de la chaîne de type.
Donc, cela stocke un message et ensuite requis
est vrai, puis nous allons également ajouter un autre champ appelé auteur,
qui est de la chaîne de type et obligatoire est vrai.
Nous allons également ajouter le champ horodatage pour cela,
et définir cela sur true.
Donc, pour chaque commentaire qui est ajouté,
nous allons également stocker l'horodatage correspondant.
Donc, maintenant que nous avons déclaré un schéma de commentaire,
nous pouvons alors aller de l'avant et modifier le schéma plat pour être en mesure de stocker des commentaires.
Ainsi, dans le schéma de plats,
nous pouvons ajouter des commentaires
qui est un tableau du schéma de commentaire de type,
ce qui signifie que chaque objet plat,
document plat peut avoir plusieurs commentaires stockés dans un tableau à l'intérieur du document plat.
Donc, ce sont les documents de commentaire devient sous-documents à l'intérieur d'un document plat.
Donc, nous stockons tous les commentaires sur le plat à l'intérieur
du plat lui-même comme un tableau de documents de commentaires.
Donc, c'est l'utilisation du sous-document dans Mongoose.
Après cela, allons dans le fichier index.js, puis modifions notre fichier index.js.
Ici, ils créent le plat comme avant.
Ensuite, après avoir créé le plat,
puis nous consolons le journal du plat.
Par la suite, nous mettrons à jour le plat.
Donc, nous dirons que les plats trouvent par ID et mise à jour.
Donc, nous allons modifier le plat que nous venons d'insérer à l'étape précédente.
Donc, nous allons dire, « Trouver par ID et mettre à jour. »
Et nous allons nous approvisionner.
En cela prend deux paramètres,
le premier paramètre est le plat.
Maintenant, ce plat. _id fait bien sûr référence à ce plat que nous venons d'insérer,
puis nous allons modifier ce même plat à l'étape suivante.
Alors, on va dire : « Dish. _id. » Et puis,
entre parenthèses, nous spécifions $set, description,
test mis à jour et nouveau vrai.
Donc, ceci, nous modifions le plat que nous
venons d'insérer en mettant à jour sa description là.
Maintenant, cela doit être enfermé à l'intérieur.
Ce deuxième drapeau que nous fournissons ici,
nouveau côlon égal à vrai,
signifie qu'une fois que la mise à jour du plat est terminée,
alors cela
nous retournera le plat, plat mis à jour.
Donc, c'est la raison d'utiliser ce drapeau ici, disons, nouveau vrai.
Donc, ce plat sera retourné à l'étape suivante.
Donc, on va prendre ce plat et ensuite imprimer ce plat.
Donc, à l'étape suivante,
nous allons modifier ceci et dire, « Ceci, puis plat. »
Et puis, on va faire un journal de la console.
Ensuite, nous allons insérer un commentaire dans le plat.
Donc, nous allons dire, « plat.Comments.Push. »
Rappelons que les commentaires sont un champ à l'intérieur du plat.
Donc, en revenant au schéma,
nous voyons que ces commentaires sont un tableau du type CommentSchema.
Donc, ce qui signifie que nous pouvons pousser un élément dans ce tableau.
Donc, en revenant ici,
nous dirons : « Les commentaires de la vaisselle poussent. »
Et puis, nous allons pousser un document de commentaire dans le plat ici.
Donc, je vais dire, « Les commentaires de Dish poussent. »
Et spécifiez les champs ici.
Donc, nous allons dire, « Note cinq, commentaire et auteur. »
Et donc, cela va pousser ce commentaire dans le champ de commentaire de ce plat spécifique.
Donc, maintenant que nous avons modifié le plat,
la prochaine étape que nous allons faire est de,
laissez-moi fermer ceci et ensuite mettre ça dedans, puis là.
Je vais revenir et réparer ça dans un peu de temps.
Donc, maintenant que nous avons modifié le plat,
nous devons sauver le plat.
Donc, nous allons dire, « Renvoyez le plat en toute sécurité. »
Donc, dans cette étape,
nous insérons un commentaire dans le plat,
le plat que nous venons de créer et de mettre à jour,
puis nous enregistrons ce commentaire ;
puis, cela retournera le plat.
Et quand le plat est retourné dans le rappel suivant,
je vais alors dire, « Console bûche ».
Et puis, après cela,
nous dirons : « Retournez. »
Donc, avec cela, nous avons modifié notre fichier index.js.
Sauvegardons les modifications et regardons cette application.
Aller au terminal,
lançons npm start, puis voyons la valeur résultante ici.
Donc, pour revenir en arrière, nous voyons que dans la première étape,
nous avons créé ce plat ici avec le nom et la description comme nous l'avons donné plus tôt.
Et puis, une fois que le plat est créé,
dans la deuxième étape,
nous avons mis à jour le plat, puis imprimé la version mise à jour du plat.
Ainsi, la version mise à jour du plat est imprimée juste là.
Et vous pouvez voir que la description a été mise à jour à partir du cas précédent,
mais l'identifiant reste exactement le même que le plat que nous avons créé précédemment.
Et le champ de commentaires,
comme vous pouvez le voir ici,
est un tableau vide et le fumé.
Dans la troisième étape, nous poussons le commentaire dans notre plat ici ;
puis, ce commentaire particulier que
nous avons ajouté a été ajouté dans ce tableau de commentaires.
Donc, vous pouvez voir ce commentaire être joint ici,
et c'est le plat mis à jour qui a maintenant été imprimé sur l'écran ici.
Donc, vous pouvez voir que nous avons fait plusieurs étapes l'une après l'autre avec notre plat.
Nous avons d'abord créé le plat,
puis nous avons mis à jour le plat,
puis nous avons inséré un commentaire dans le plat,
qui est un sous-document à l'intérieur du document plat ;
puis, nous vous avons imprimé le résultat.
Avec cela, nous complétons cet exercice.
Dans cet exercice, nous avons vu comment nous pouvons, d'
abord, créer un plat en utilisant des plats créer,
puis nous avons vu l'utilisation de sous-documents : là,
nous avons défini un schéma dans le
fichier dishes.js, puis utilisé le schéma de commentaire que nous avons défini
puis défini le champ dans le schéma de plats comme un du type CommentSchema.
Et puis, dans le fichier index.js,
nous avons pu créer un plat,
mettre à jour le plat et aussi pousser
un document de commentaire dans le plat, puis enregistrer les modifications ici.
Avec cela, nous complétons cet exercice.
C' est un bon moment pour vous de faire un Git Kermit avec le message, « Mongoose troisième partie ».