Comment insérez-vous, mettez-à-jour et supprimez des documents ?

Question

IT Interview Practice · Accepted Answer

MongoDB modifie les données avec les méthodes **insert** (`insertOne`/`insertMany`), **update** (`updateOne`/`updateMany` avec des opérateurs), et **delete** (`deleteOne`/`deleteMany`). Les mises à jour utilisent des **opérateurs de mise à jour** plutôt que de remplacer des documents entiers — une distinction importante.

## Insérer

```js
db.users.insertOne({ name: "Ann", age: 30 });          // → returns the inserted _id
db.users.insertMany([{ name: "Bob" }, { name: "Carol" }]);   // bulk insert (efficient)
```

## Mettre à jour avec des opérateurs (ne remplacez pas le document entier)

```js
// updateOne — filter (which doc) + update (with OPERATORS)
db.users.updateOne(
  { name: "Ann" },
  { $set: { age: 31, status: "active" } }   // $set: change specific fields
);

// common update operators
{ $set: { field: value } }       // set/change a field
{ $unset: { field: "" } }         // remove a field
{ $inc: { count: 1 } }            // increment a number
{ $push: { tags: "new" } }        // add to an array
{ $pull: { tags: "old" } }        // remove from an array
{ $addToSet: { tags: "x" } }      // add to array only if not present
```

```js
db.users.updateMany({ active: false }, { $set: { archived: true } });  // update all matching
```

**Important :** les mises à jour utilisent des **opérateurs** (`$set`, `$inc`, `$push`, etc.) pour modifier des *champs spécifiques*. Sans opérateur, vous *remplaceriez le document entier* — une erreur courante :

```js
// ❌ this REPLACES the whole document (loses other fields!)
db.users.updateOne({ name: "Ann" }, { age: 31 });   // Ann now has ONLY age!
// ✅ use $set to change just the field
db.users.updateOne({ name: "Ann" }, { $set: { age: 31 } });
```

## Supprimer

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

## Upsert — insérer si non trouvé

```js
db.users.updateOne(
  { email: "ann@x.com" },
  { $set: { name: "Ann" } },
  { upsert: true }            // if no match, INSERT a new document
);
```

## Pourquoi c'est important

Les opérations d'insertion, de mise à jour et de suppression sont comment les applications **modifient les données** dans MongoDB, fondamental pour toute application orientée données, donc les comprendre est essentiel pour vos connaissances quotidiennes.

Connaître les méthodes (`insertOne`/`insertMany` pour créer, `updateOne`/`updateMany` pour modifier, `deleteOne`/`deleteMany` pour supprimer) couvre les bases.

Le **point le plus important et le plus mal compris** est que les mises à jour MongoDB utilisent des **opérateurs de mise à jour** (`$set`, `$inc`, `$push`, `$pull`, etc.) pour modifier des *champs spécifiques* — et crucialement, **oublier l'opérateur remplace le document entier** (une erreur notoire où `updateOne({...}, {age: 31})` efface tous les autres champs, ne laissant que `age`), donc comprendre d'utiliser toujours `$set` (et les autres opérateurs) pour les mises à jour au niveau des champs est essentiel pour la correction.

Connaître les opérateurs courants (`$set`, `$inc` pour les compteurs, `$push`/`$pull`/`$addToSet` pour les tableaux — les opérateurs de tableaux étant particulièrement pertinents étant donné les documents riches en tableaux de MongoDB) est une connaissance quotidienne importante.

Comprendre l'**upsert** (`{ upsert: true }` — insérer si aucune correspondance n'existe, l'insert-ou-mise-à-jour de MongoDB) est précieux pour le modèle courant d'insertion ou mise à jour.

Il est aussi à noter le danger de `deleteMany({})` (supprimer tout — similaire au danger du WHERE manquant en SQL).

Puisque modifier les données est fondamental, et puisque les mises à jour basées sur les opérateurs de MongoDB (avec le piège du remplacement de document), les opérateurs de tableaux, et l'upsert sont comment vous modifiez correctement les données, comprendre insert/update/delete — notamment la distinction critique des opérateurs de mise à jour (éviter le remplacement accidentel de document) — est une connaissance essentielle et incontournable pour tout développement MongoDB, où le piège des opérateurs en particulier est une source fréquente de bugs réels.

Insérer

Mettre à jour avec des opérateurs (ne remplacez pas le document entier)

Supprimer

Upsert — insérer si non trouvé

Pourquoi c'est important

Questions connexes