Dans la leçon précédente,
nous avons appris sur le pilote MongoDB.
Cela permet à notre application de nœud de communiquer avec un serveur MongoDB,
ainsi que de stocker et de récupérer des documents à partir du serveur MongoDB.
Nous avons également vu que le pilote MongoDB nous fournit de
nombreuses méthodes qui nous permettent de créer des collections dans une base de données, d'
ajouter des documents aux collections,
puis d'effectuer diverses opérations sur les documents d'une collection.
Maintenant, lorsque les documents sont stockés dans la base de données,
le pilote MongoDB lui-même n'impose aucune structure sur les documents.
Si nous avons besoin d'avoir une structure spécifique pour les documents et d'appliquer cette structure,
alors nous devons utiliser le module de noeud Mongoose qui nous permet de définir
un schéma et une structure pour nos documents qui sont stockés dans notre base de données MongoDB,
et applique strictement la structure.
Regardons plus de détails dans cette conférence et les exercices qui suivent cette conférence.
Comme nous l'avons déjà appris,
MongoDB stocke des données dans des collections dans une base de données.
Ces collections se composent d'une collection de documents.
Les documents eux-mêmes stockés dans
une base de données MongoDB n'ont pas de structure spécifique imposée au document.
N' importe quel document peut être stocké dans n'importe quelle collection.
MongoDB s'appuie sur le développeur pour appliquer la structure sur les documents,
et donne l'entière responsabilité au développeur de s'assurer que les documents
de la structure correcte sont ajoutés et maintenus dans les différentes collections.
Maintenant, il est très facile de violer cela.
Ainsi, par exemple, même si vous pouvez commencer par l'hypothèse
qu'une connexion particulière aura des documents d'une certaine structure,
vous pouvez facilement insérer des documents qui ne sont pas nécessairement conformes à la structure.
Si vous êtes très particulier que la structure des documents dans
une collection a toujours une structure spécifiée,
et aura toujours l'ensemble spécifique de champs,
alors MongoDB lui-même n'impose pas que
le pilote MongoDB nœud que nous avons vu dans la leçon précédente.
C' est là que nous aurons besoin d'un moyen plus formel d'imposer une
structure sur les documents qui sont stockés dans une collection dans une base de données MongoDB.
C' est là que le module de noeud Mongoose vient à notre aide.
Le module de noeud Mongoose impose
une structure standardisée pour les documents stockés dans une collection particulière.
Donc, c'est pourquoi nous entendons souvent parler de cela comme le Mongoose ODM.
L' ODM lui-même est interprété par certaines personnes
comme signifiant Modèle de données d'objet ou parfois appelé Mappage de document d'objet,
ou certaines personnes le désignent comme ORM ou Mappage relationnel d'objet.
Maintenant, quand nous parlons de relationnel qui s'applique beaucoup plus aux bases de données relationnelles,
mais avec les bases de données SQL, nous avions besoin explicitement de
mettre l'objet vers le mappage relationnel entre la base de données et notre application elle-même.
Parce que dans l'application, nous regarderions
les objets mais leur stockage dans une base de données SQL sera sous la forme d'enregistrements,
et vous avez donc besoin d'un mappage explicite.
Comme nous l'avons vu avec la base de données NoSQL,
cela n'était pas explicitement requis.
Mais si vous avez besoin d'imposer une structure à vos documents qui sont stockés dans une collection
, alors l'utilisation de Mongoose pour imposer cette structure est très, très utile.
La façon dont Mongoose se déplace en
imposant une structure sur les documents est par l'utilisation de schémas.
Schéma, définit la structure de leurs documents.
Parlons de ça un peu plus en détail.
Alors, quel est exactement le schéma de mongoose,
et qu'est-ce qu'il apporte à la table ?
schéma Mongoose, implique une structure sur
les données qui sont stockées dans un document dans votre base de données.
Ainsi, il définit tous les champs de votre document,
et spécifie également les types de champs,
et peut également nous fournir des
fonctionnalités supplémentaires qui peuvent activer la validation sur ces champs.
Ainsi, par exemple, les différents types de schéma pris en charge dans Mongoose incluent : String,
Number, Date, Buffer, Boolean,
Mixed, Object ID et Array.
En particulier, nous allons examiner le numéro de chaîne,
et une date, et booléen dans l'exercice qui suit.
Nous examinerons quelques-uns des autres dans des exercices ultérieurs.
En particulier, notez l'utilisation du type de schéma de tableau.
Ainsi, un type de schéma de tableau vous permettrait de
créer un tableau de sous-documents à l'intérieur du document.
J' en parlerai dans un court moment.
Une fois que vous définissez un schéma,
le schéma est ensuite utilisé dans Mongoose pour créer une fonction de modèle,
et c'est ce qui vous permet de définir la structure de vos documents dans la base de données.
Les schémas eux-mêmes peuvent avoir une imbrication.
Donc, ce qui signifie que vous pouvez avoir un sous-document qui sont inclus dans un document.
Les sous-documents sont généralement pris
en charge soit en spécifiant un schéma supplémentaire,
puis en définissant l'un des champs du schéma pour être hors du type de l'autre schéma.
Ou vous pouvez même aller avec un tableau d'
un autre type de schéma dans un second schéma que vous définissez.
Regardons un exemple pour clarifier certains d'entre eux plus en détail.
Cet exemple sera tiré de l'exercice que vous ferez juste après cette conférence.
Avant de pouvoir parler de schémas et de modèles en Mongoose,
comprenons pourquoi nous aurions besoin de cela.
Si vous avez suivi le cours angulaire précédent,
ou ionique, ou le cours de script natif,
vous avez vu que nous représentons
diverses données que nous utilisons dans nos applications sous la forme de chaînes JSON.
Donc, dans notre application, nous définissons une collection appelée vaisselle.
Dans une collection de plats,
chaque plat contiendra un certain ensemble de propriétés définies sous la forme d'une chaîne JSON,
comme vous le voyez dans cet exemple ici.
Ainsi, la vaisselle est un tableau de type plat,
et chaque plat lui-même contiendra un nom,
une image, une catégorie,
une étiquette, et ainsi de suite.
En outre, à l'intérieur du document plat lui-même,
vous auriez des commentaires qui sont stockés comme un tableau de nouveau, -
documents JSON qui contiennent des champs spécifiques étape.
Ainsi, chaque commentaire, par exemple,
contient un auteur de commentaire de notation et un champ de date comme vous le voyez dans cet exemple ici.
Ainsi, vous voyez qu'il y a une structure claire à
chaque document qui définit un plat qui est stocké dans notre base de données.
De toute évidence, plusieurs plats seront stockés sous la forme d'une collection dans notre base de données,
et pourraient être regroupés et envoyés comme une gamme de
plats à notre application client à utiliser.
Maintenant que nous avons compris comment cela est défini, maintenant,
comment cela se rapporte-t-il au schéma mongoose et au modèle que nous définissons en Mongoose ?
Maintenant, notez la structure d'un document plat typique ici.
Ainsi, cela pourrait être facilement mappé dans un document MongoDB dans une collection,
peut-être appelée la collection vaisselle.
Donc, nous voyons qu'il y a une structure claire au document lui-même.
Maintenant, comment pouvons-nous refléter cela dans un schéma dans notre application Mongoose ?
Comme vous l'apprendrez dans l'exercice,
nous verrons que nous définirons des schémas en Mongoose.
Donc, le schéma est défini comme un schéma Mongoose ici.
À titre d'exemple, un CommentSchema est montré ici.
Le CommentSchema, comme vous pouvez le voir,
contient trois champs différents : l'évaluation, le commentaire
et le champ auteur,
ainsi que des horodatages ici.
Les horodatages vous permettent d'avoir deux champs différents dans
le document : le champ créé à et le champ mis à jour à,
qui sont tous deux des horodatages stockés sous la forme d'une chaîne de date ISO dans le document.
Maintenant, la note elle-même serait une valeur entière.
Donc, dans la terminologie mongoose,
il sera stocké sous forme de nombre,
le type serait un nombre.
Vous pouvez même spécifier la valeur minimale et la valeur maximale.
Vous pouvez également spécifier que ce champ particulier est obligatoire, ce
qui signifie que chaque document du type de commentaire doit contenir un champ d'évaluation.
De même, vous pouvez également définir un champ de commentaire,
qui est de la chaîne de type.
Donc, évidemment, un commentaire n'est rien d'autre qu'une chaîne qui contient des informations,
et cela peut également être défini comme un champ obligatoire, ce
qui signifie que chaque document doit contenir un commentaire,
et aussi un champ auteur,
qui est également de la chaîne de type.
Donc, vous voyez cela en définissant ce schéma dans ce format.
Comme nous l'avons appris dans la discussion un peu plus tôt, le
schéma est défini en utilisant les différents types que nous avons dans notre application Mongoose.
Donc, dans le schéma, encore une fois,
vous voyez trois champs différents ici,
notation, commentaire et auteur ici,
et chacun d'entre eux a un type spécifique donné,
puis si cela est requis ou non.
Ainsi, vous imposez une structure stricte
sur les documents de commentaires qui vont stocker dans votre application.
Maintenant que nous avons défini un schéma de commentaire, nous pouvons alors,
comme vous l'avez remarqué à partir de l'exemple du type de données que nous avons besoin dans notre application,
nous avons un document plat lui-même.
Le document plat contient divers champs.
Ici, dans l'exercice,
nous allons d'abord introduire seulement deux champs dans le document plat,
le nom et la description.
Dans la leçon suivante,
nous allons présenter les champs restants pour le Dish.Schema.
Maintenant, donc le nom,
comme dans ce cas,
est de la chaîne de type.
Nous pouvons également spécifier qu'il s'agit d'un champ obligatoire, ce
qui signifie que chaque document doit contenir le champ de nom.
Nous pouvons également spécifier que le champ de nom est unique,
ce qui signifie qu'aucun document ne peut avoir exactement la même valeur de nom dans le document.
Ainsi, cela garantit que chaque document aura
un champ de nom unique et un champ de description,
qui est de nouveau de la chaîne de type,
mais également spécifié comme requis.
Maintenant, comme nous l'avons vu dans l'exemple,
un document plat contient plusieurs commentaires inclus dans le document.
Maintenant, dans Mongoose, cela est pris en charge par l'utilisation de sous-documents. Par
conséquent, si vous définissez un schéma plus tôt,
par exemple, nous avons déjà défini un CommentSchema ici,
vous pouvez également définir un champ dans un autre schéma que vous définissez,
puis spécifier que ce champ sera
du type du schéma précédent que vous avez défini.
Donc, dans ce cas,
le champ de commentaires, je le définit comme un tableau,
donc vous voyez l'utilisation d'un type de tableau dans votre schéma que vous définissez ici,
puis tableau du type CommentSchema.
Donc, il s'agit d'un tableau de commentaires qui seront inclus dans chaque document plat.
Ainsi, vous pouvez avoir
plus d'un sous-document de commentaire dans un document plat.
Ainsi, définir la structure comme celle-ci nous permet de prendre en charge
la structure de chaîne JSON correspondante que nous avons définie
pour un document plat ou que nous avons vu dans l'exemple précédent.
Maintenant, une fois que nous définissons le schéma,
pour en faire usage dans notre application,
nous devons créer un modèle à partir de ce schéma que nous venons de définir.
Ainsi, dans notre application,
nous allons définir un modèle Mongoose et spécifier que le modèle
est hors du type Dish.Schema dans cet exemple.
Non seulement cela, vous donnerez également un nom au modèle ici.
Donc, lorsque vous donnez un nom au modèle ici,
nous spécifions le nom comme plat.
Maintenant, lorsque vous utilisez ce modèle plat dans
notre application de noeud où nous utilisons Mongoose,
alors cela sera transformé et mappé en une collection dans ma base de données MongoDB.
La collection elle-même sera nommée comme des plats.
Ainsi, Mongoose sait automatiquement que lorsque vous spécifiez un nom ici,
il construira automatiquement le pluriel
de ce nom, puis donnera à la collection le nom,
qui est le pluriel du nom de modèle que vous spécifiez dans cet exemple ici.
Donc, quand je dis plat ici,
alors Mongoose mappera automatiquement cela dans
la collection de plats dans la base de données MongoDB.
Comment sait-il convertir ce nom singulier en pluriel ?
Mongoose a automatiquement un mécanisme intégré qui
lui permet de construire les pluriels de mots anglais standard.
Donc, si vous dites plat,
il va construire des plats.
Si vous dites leader, il construira le pluriel de celui-ci en tant que leaders, et ainsi de suite.
Donc, cela est déjà intégré dans le module de noeud Mongoose.
Donc, c'est pourquoi quand je spécifie ceci comme un type de modèle plat,
alors Mongoose construira la collection de plats dans ma base de données MongoDB,
puis cette collection de plats stockera
les différents documents du type plat dedans.
Une fois que nous avons créé cela, généralement,
lorsque nous déclarons des modèles dans notre application,
nous les stockons dans un sous-dossier nommé modèles, juste pour plus de commodité.
Vous n'avez pas besoin de le faire,
mais juste pour organiser votre application,
nous le stockons normalement dans un dossier nommé modèles.
Ensuite, le schéma et le modèle seraient
définis dans un fichier comme celui-ci comme vous le voyez dans l'exemple ici,
ce appelé dishes.js, puis cela serait exporté car il s'agit d'un module de nœud.
Cela sera exporté à partir de ce fichier afin qu'il puisse être inclus dans l'application
de nœud, où nous allons utiliser
ce schéma et le modèle que nous venons de définir ici.
Avec cette compréhension rapide du schéma et du modèle et
son utilisation dans la définition de la structure d'un document que nous stockons dans un MongoDB,
revenons en arrière et comprenons un peu plus sur ce que Mongoose nous fournit.
En outre, Mongoose nous permet d'établir la connexion avec le serveur MongoDB.
Mongoose utiliser en interne
le pilote MongoDB que nous avions utilisé dans l'exercice précédent.
Donc, Mongoose dépend du pilote MongoDB, donc,
ce qui signifie que de votre application de nœud basée sur Mongoose,
vous pouvez utiliser toutes les méthodes qui sont déjà
disponibles à partir du pilote MongoDB aussi si vous le choisissez,
mais Mongoose lui-même a sa propre collection de méthodes que nous
pouvons faire utilisation de pour interagir avec la base de données MongoDB,
comme nous le verrons dans l'exercice qui suit.
Permettez-moi de vous montrer brièvement comment établir une connexion à la base de données,
et vous le ferez dans l'exercice qui suit.
Donc, tout comme nous avons déclaré l'URL dans le cas
de l'application de nœud MongoDB dans la leçon précédente,
nous allons toujours déclarer l'URL de notre application.
Ensuite, nous allons utiliser la méthode de connexion Mongoose
et fournir l'URL de la méthode de connexion Mongoose,
ce qui établira la connexion à la base de données.
Avec cette compréhension rapide de Mongoose et le rôle que
joue Mongoose dans la prise en charge de l'insertion structurée
, du stockage et de la récupération de documents de notre MongoDB,
passons à l'exercice où nous
obtiendrons une expérience pratique en utilisant le module Mongoose.