Comment fonctionnent les opérations CRUD dans MongoDB ?

Question

Accepted Answer

**CRUD** (Create, Read, Update, Delete) — les opérations de création, lecture, mise à jour et suppression — dans MongoDB utilisent des méthodes sur les collections. Elles fonctionnent avec des documents et utilisent une syntaxe de requête flexible de type JSON — différente de SQL mais conceptuellement similaire.

## Create — insérer des documents

```js
db.users.insertOne({ name: "Ann", age: 30 });          // insert one document
db.users.insertMany([                                   // insert multiple
  { name: "Bob", age: 25 },
  { name: "Carol", age: 28 }
]);
// each gets an auto-generated _id if not provided
```

## Read — interroger des documents

```js
db.users.find();                              // all documents
db.users.find({ age: 30 });                   // WHERE age = 30 (a query filter object)
db.users.find({ age: { $gt: 25 } });          // age > 25 ($gt operator)
db.users.findOne({ name: "Ann" });            // the first match
db.users.find({ active: true }, { name: 1 }); // projection — return only the name field
```

Les requêtes utilisent un **document de filtre** (`{ field: value }`) décrivant ce qui doit correspondre, avec des opérateurs (`$gt`, `$lt`, `$in`, etc.) pour les conditions. La projection (`{ name: 1 }`) sélectionne les champs à retourner.

## Update — modifier des documents

```js
// updateOne/updateMany with UPDATE OPERATORS ($set, $inc, etc.)
db.users.updateOne(
  { name: "Ann" },                  // filter — which document
  { $set: { age: 31 } }              // update — $set changes a field
);
db.users.updateMany(
  { active: false },
  { $set: { status: "inactive" } }   // update all matching
);
db.users.updateOne({ name: "Ann" }, { $inc: { loginCount: 1 } });  // increment
```

Les mises à jour prennent un **filtre** (quels documents) et un **document de mise à jour** utilisant des **opérateurs** comme `$set` (définir un champ), `$inc` (incrémenter), `$push` (ajouter à un tableau) — vous ne remplacez pas le document entier (sauf intention contraire).

## Delete — supprimer des documents

```js
db.users.deleteOne({ name: "Ann" });          // delete the first match
db.users.deleteMany({ active: false });        // delete all matching
```

## Pourquoi c'est important

Les opérations CRUD sont le fondement de tout travail avec une base de données, donc comprendre comment elles fonctionnent dans MongoDB est une connaissance essentielle et quotidienne pour l'utiliser.

Les opérations — **insérer** des documents (`insertOne`/`insertMany`), **interroger** avec des documents de filtre et des opérateurs (`find`/`findOne` avec des filtres `{ field: value }`, des opérateurs de comparaison comme `$gt`, et des projections pour sélectionner les champs), **mettre à jour** avec des filtres et des opérateurs de mise à jour (`updateOne`/`updateMany` avec `$set`, `$inc`, etc.), et **supprimer** (`deleteOne`/`deleteMany`) — c'est comment les applications créent, lisent, modifient et suppriment des données dans MongoDB, ce qui est le cœur de la plupart des interactions avec les bases de données.

Comprendre l'approche distinctive de MongoDB est important : les requêtes utilisent un **document de filtre** (un objet de type JSON décrivant ce qui doit correspondre, avec des opérateurs) plutôt que la syntaxe `WHERE` de SQL, et les mises à jour utilisent des **opérateurs de mise à jour** (`$set` pour modifier les champs, `$inc` pour incrémenter, `$push` pour les tableaux) plutôt que le remplacement du document complet — un modèle différent mais apprenable.

Puisque CRUD est l'opération fondamentale et constante dans toute application orientée données, et puisque les méthodes CRUD de MongoDB, les requêtes avec document de filtre et opérateurs, et les opérateurs de mise à jour sont comment vous interagissez avec la base de données au quotidien, comprendre les opérations CRUD MongoDB — les méthodes, la syntaxe de requête filtre/opérateur, et les opérateurs de mise à jour — est une connaissance essentielle et incontournable pour tout développement MongoDB, l'équivalent de connaître SELECT/INSERT/UPDATE/DELETE pour SQL et le fondement pratique du travail avec la base de données.