0Pricing
Node.js Backend Development Bootcamp · Leçon

ODM Mongoose pour la modélisation des données

Apprenez à définir des schémas et des modèles avec Mongoose afin de structurer efficacement vos données dans MongoDB.

ODM Mongoose pour la modélisation des données est une leçon Node.js Backend Development Bootcamp gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Node.js Backend Development Bootcamp, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Node.js Backend Development Bootcamp comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Meet Mongoose Schemas

In the last lesson, we connected to MongoDB. Now, let's learn how to structure our data with Mongoose and Schemas.

Mongoose is an Object Data Modeling (ODM) library for MongoDB and Node.js. It provides a straightforward, schema-based solution to model your application data, making it easier to work with MongoDB.

Why Schemas Matter

MongoDB is a NoSQL database, meaning it's schema-less by default. While this offers great flexibility, it can lead to inconsistent data if not managed.

Mongoose schemas bring structure and consistency:

  • Define Data Shape: What fields a document should have.
  • Data Types: Ensure fields store correct types (String, Number, etc.).
  • Validation: Add rules like 'required' or 'minimum length'.

Defining Your First Schema

Let's define a basic schema for a Book. We'll specify properties like title and author, and their expected data types.

First, we need to import Mongoose, then create a new Schema object.

const mongoose = require('mongoose');

// Define the Book Schema
const bookSchema = new mongoose.Schema({
  title: String,
  author: String,
  pages: Number,
  isPublished: Boolean
});

console.log('Book Schema defined!');
// In a real app, this schema would be used to create a model.

Common Schema Types

Mongoose supports many data types that map to JavaScript types and MongoDB BSON types. Here are some of the most common ones:

  • String: For text like names, descriptions.
  • Number: For numerical values like age, price.
  • Boolean: For true/false values.
  • Date: For storing dates and times.
  • ObjectId: A special type for unique IDs, often used for references between documents.

Schema Options: Required & Default

Beyond just types, schemas allow you to add options to each field. These options control behavior and validation. Two common ones are required and default.

  • required: true: Means this field must have a value.
  • default: 'value': Provides a fallback value if none is specified during document creation.
const mongoose = require('mongoose');

const productSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true // Name is mandatory
  },
  price: {
    type: Number,
    required: true,
    default: 0 // Default price is 0 if not set
  },
  createdAt: {
    type: Date,
    default: Date.now // Automatically set current date
  }
});

console.log('Product Schema with options defined!');

Creating a Mongoose Model

A schema is like a blueprint. To actually interact with your MongoDB collection, you need to create a Model from that schema.

A Mongoose Model is a wrapper around the schema that provides an interface for the database: creating, querying, updating, and deleting records in a specific collection.

const mongoose = require('mongoose');

// Define a simple User Schema
const userSchema = new mongoose.Schema({
  name: String,
  email: String
});

// Create a Model from the schema
// 'User' is the singular name. Mongoose will use 'users' as collection name.
const User = mongoose.model('User', userSchema);

console.log('User Model created from schema!');
// Now you can use the User model to interact with the 'users' collection.

Basic Field Validation

Mongoose schemas offer built-in validation to ensure data integrity before saving to the database. This helps keep your data clean and consistent.

You can define validators like minlength, maxlength, and enum (a list of allowed values) directly within your schema definition.

const mongoose = require('mongoose');

const taskSchema = new mongoose.Schema({
  description: {
    type: String,
    required: true,
    minlength: 5, // Must be at least 5 characters
    maxlength: 100 // Max 100 characters
  },
  status: {
    type: String,
    enum: ['pending', 'completed', 'cancelled'], // Only these values allowed
    default: 'pending'
  }
});

console.log('Task Schema with validation rules defined!');

Embedding Documents

Sometimes, one document logically 'contains' another. Mongoose allows you to embed schemas directly within other schemas, creating nested documents.

This is useful for tightly coupled data that doesn't need its own separate collection, like an address within a user profile.

const mongoose = require('mongoose');

// Define an Address Schema
const addressSchema = new mongoose.Schema({
  street: String,
  city: String,
  zip: String
});

// Embed Address Schema within a Person Schema
const personSchema = new mongoose.Schema({
  name: String,
  // The 'address' field will be a nested document using addressSchema
  address: addressSchema 
});

console.log('Person Schema with embedded Address Schema defined!');
// A 'Person' document will now contain an 'address' object.

Quick Check: Schema Fields

Imagine you're building a schema for a blog post. It needs a title (required string), content (string), and publishDate (date, defaults to now).

Which of the following Mongoose schema definitions correctly sets up these fields and their options?

Recap: Schemas & Models

Great job! You've learned the essentials of Mongoose schemas and models:

  • Schemas define the structure, data types, and validation rules for your MongoDB documents.
  • They provide consistency in a schema-less database.
  • You create Models from schemas to interact with specific collections in MongoDB.
  • We explored common types, options like required and default, and even embedding documents.

Next, we'll use these models to perform CRUD operations (Create, Read, Update, Delete)!

Questions Fréquemment Posées

La leçon « ODM Mongoose pour la modélisation des données » est-elle gratuite ?

Oui — le texte complet de « ODM Mongoose pour la modélisation des données » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Node.js Backend Development Bootcamp, passe à CoddyKit PRO. Le cours Node.js Backend Development Bootcamp comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « ODM Mongoose pour la modélisation des données » ?

Apprenez à définir des schémas et des modèles avec Mongoose afin de structurer efficacement vos données dans MongoDB. Tu pratiques Node.js Backend Development Bootcamp avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Node.js Backend Development Bootcamp ?

Aucune expérience préalable n'est requise. Node.js Backend Development Bootcamp sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « ODM Mongoose pour la modélisation des données » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Node.js Backend Development Bootcamp ?

Oui. Chaque leçon Node.js Backend Development Bootcamp inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Connecter Node.js à MongoDB
  2. ODM Mongoose pour la modélisation des données
  3. Opérations CRUD avec Mongoose
  4. Interroger et filtrer les données avec Mongoose
← Retour à Node.js Backend Development Bootcamp