La gestion des données dans une base de données MongoDB peut s’avérer difficile, en particulier lorsqu’il s’agit de modèles de données complexes. MongoDB est une base de données sans schéma, ce qui signifie que les données peuvent être ajoutées sans suivre une structure particulière. Cette flexibilité fait de MongoDB une base de données idéale pour le stockage de grandes quantités de données, mais rend également la gestion des données plus difficile.
Mongoose fournit une solution basée sur un schéma qui permet de s’assurer que les données enregistrées dans MongoDB sont cohérentes et correctement formatées. Avec Mongoose, vous pouvez définir un schéma pour vos modèles de données, qui spécifie la structure des données et les règles de formatage de ces données. Vous découvrirez ici comment utiliser Mongoose dans une application Express.
Configuration de votre environnement de développement
Avant d’utiliser Mongoose, vous devez l’installer en tant que dépendance dans votre projet.
Vous pouvez installer Mongoose en exécutant la commande ci-dessous :
npm install mongoose
Après avoir installé Mongoose dans votre projet, vous devez connecter votre application à MongoDB en utilisant Mongoose.
Mongoose se connecte à une base de données MongoDB à l’aide de l’option connect qui prend un URI MongoDB comme argument.
Voici un exemple :
// index.js
const mongoose = require("mongoose")
mongoose.connect("mongodb://127.0.0.1:27017/example", () =>
console.log("Connected to database successfully")
);
Le bloc de code ci-dessus se connecte à une instance locale de MongoDB et enregistre un message de réussite lorsque votre application se connecte avec succès à MongoDB.
Création d’un modèle Mongoose
Un modèle Mongoose est une classe basée sur un schéma dans Mongoose qui vous permet d’interagir avec une collection MongoDB.
Un schéma Mongoose définit la structure des documents que vous pouvez stocker dans une collection MongoDB et fournit une interface pour la création, la lecture, la mise à jour et la suppression de documents dans cette collection.
Lorsque vous définissez un modèle Mongoose, vous définissez le schéma des documents de cette collection, y compris les propriétés, leurs types et les validations.
Voici un exemple de modèle Mongoose pour une collection de Utilisateur collection :
const mongoose = require("mongoose");
const userSchema = mongoose.Schema({
name: {
type: String,
required: [true, "Name is required"],
},
email: {
type: String,
required: true,
},
age: {
type: Number,
validate: {
validator: function (value) {
return value > 0;
},
message: () => "Please enter a valid age",
},
},
});
const User = mongoose.model("User", userSchema);
module.exports = User;
Le bloc de code ci-dessus définit un schéma Mongoose avec trois propriétés : nom, emailet âge. Chaque propriété possède un ensemble défini de règles que vous devez suivre pour faire correspondre une valeur à son champ spécifié. Voici un aperçu de ces règles :
- nom: Les nom le bien est un chaîne de caractères type marqué comme requisce qui signifie que vous devez associer une chaîne de caractères à ce champ. Si vous laissez le champ vide ou si vous entrez un type de données JavaScript différent, Mongoose génère une erreur.
- email: Le email la propriété est un chaîne de caractères type marqué comme requis. Il n’y a pas d’autres règles de validation, mais en pratique, vous devriez valider si le courriel est correct. Vous pouvez valider le courriel en utilisant des expressions rationnelles ou des bibliothèques tierces, telles que class-validator.
- âge: L’âge âge la propriété est un nombre avec une règle de validation personnalisée qui vérifie si la valeur associée au champ est supérieure à zéro. Si la valeur ne passe pas la validation, Mongoose lève une erreur avec le message suivant Veuillez saisir un âge valide. Vous pouvez laisser ce champ vide car il n’est pas marqué comme requis.
Après avoir défini le schéma, le bloc de code crée un modèle Mongoose appelé Utilisateur utilisant mongoose.model() méthode. Cette méthode prend deux arguments : le nom du modèle et le schéma à utiliser pour les documents.
Enfin, la méthode Utilisateur est exporté vers d’autres parties de votre application.
Interagir avec MongoDB en utilisant Mongoose
Une fois votre application connectée à une base de données MongoDB et votre modèle créé et accessible aux autres parties de votre application, vous pouvez interagir avec votre base de données en utilisant les méthodes fournies par Mongoose.
Pour ce tutoriel, vous effectuerez des opérations CRUD sur une base de données MongoDB.
Note: Veillez à importer votre modèle Mongoose dans tous les modules où vous effectuerez les opérations CRUD.
Par exemple :
// router.js
const User = require("./userModel")
Création d’un document
Un document est une instance d’un modèle. Il existe plusieurs façons de créer et d’enregistrer un document dans MongoDB à l’aide de Mongoose.
Tout d’abord, vous pouvez créer une instance de la classe de votre modèle, puis appeler la fonction sauvegarder sur celui-ci.
Par exemple :
//Creating a new user
let user = new User({
name,
email,
age,
});
//Saving user to database
user
.save()
.then(() => {
console.log("User created successfully");
})
.catch((error) => {
//handle error
});
Le bloc de code ci-dessus crée et enregistre un nouveau fichier Utilisateur à votre base de données MongoDB.
Vous pouvez également enregistrer des données dans votre base de données à l’aide de la fonction créer méthode. La méthode créer instancie votre modèle et appelle la méthode save sur celle-ci. En d’autres termes, elle combine les deux opérations de la technique mentionnée précédemment.
Par exemple :
User.create({ name, email, age }, (err, data) => {
if (err) throw new Error("Internal Server Error");
console.log(`User created successfully: ${data}`);
});
Le bloc de code ci-dessus crée un nouveau Utilisateur avec les propriétés passées en argument à la fonction créer méthode.
Vous pouvez également enregistrer des données dans votre base de données à l’aide de la méthode insertMany . Bien que cette méthode ne soit idéale que pour l’enregistrement de données par lots.
Par exemple :
User.insertMany(
[
{ name, email, age },
{ name_1, email_1, age_1 },
],
(err, result) => {
if (err) {
//handle error
} else {
//Send results
}
}
);
Le bloc de code ci-dessus crée deux nouveaux documents dans la base de données Utilisateur en utilisant le tableau passé en argument à la méthode insertMany méthode.
Lecture d’un document
Vous pouvez accéder à tous les documents enregistrés dans votre base de données MongoDB à l’aide de la fonction de Mongoose méthode.
Par exemple :
User.find({})
.then((data) => {
console.log(data);
})
.catch((err) => {
//handle error
});
Le bloc de code ci-dessus renverra tous les documents de la base de données Utilisateur collection.
Vous pouvez également trouver tous les documents qui correspondent à une requête particulière en passant une requête à la méthode find.
Par exemple :
// find all documents where age is at least 18
User.find({ age: { $gte: 18 } })
.then((data) => console.log(data))
.catch((error) => console.log(error));
Le bloc de code ci-dessus renverra tous les documents dont la valeur de l’âge est supérieure à 18 dans la base de données Utilisateur collection.
Vous pouvez également lire des enregistrements individuels à l’aide de la commande findById et en passant l’ID du document comme argument ou en utilisant la méthode findOne et en passant un filtre comme argument.
Par exemple :
//findById
User.findById(id, (error, result) => {
if (result) console.log(result);
if (error) console.error(error)
});
//findOne
User.findOne({ email: "johnson@example.com" }).then((user) => {
if (!user) {
//handle error
}
//send response
});
Dans le bloc de code ci-dessus, l’élément findById renvoie le document avec l’identifiant correspondant. La méthode findOne renvoie le premier document contenant l’email johnson@example.com.
Mise à jour d’un document
Vous pouvez mettre à jour un document sur MongoDB avec Mongoose en utilisant la commande findByIdAndUpdate Méthode de recherche par ID et mise à jour. Cette méthode prend un identifiant et un objet contenant les informations mises à jour.
Par exemple :
User.findByIdAndUpdate(id, req.body, (err, doc) => {
if (doc) {
//Send response
}
if (err) {
//handle error
}
});
Le bloc de code ci-dessus met à jour le document dont l’ID correspond à l’ID fourni avec l’objet de mise à jour fourni (req.body).
Suppression d’un document
Vous pouvez supprimer un document sur MongoDB avec Mongoose en utilisant la commande findByIdAndDelete . Cette méthode prend un identifiant en argument et supprime le document avec l’identifiant correspondant.
Par exemple :
User.findByIdAndDelete(id, (error, result) => {
if (result) {
//Handle result
}
if (error) {
//Handle error
}
});
Le bloc de code ci-dessus supprime de la base de données MongoDB un document portant l’identifiant donné.
Utiliser Mongoose dans vos applications Express
Cet article donne un aperçu de la façon dont vous pouvez utiliser Mongoose dans votre application Express. Il explique comment établir une connexion à MongoDB, structurer et valider les données enregistrées dans votre base de données MongoDB, et effectuer des opérations CRUD simples.
En utilisant Mongoose dans vos applications Express, vous pouvez simplifier et rationaliser les interactions entre votre application et une base de données MongoDB.
