Comment fonctionnent les requêtes find et les projections ?

Question

Accepted Answer

La méthode **`find`** récupère les documents correspondant à un filtre ; la **projection** contrôle les champs retournés. Ensemble, elles vous permettent de interroger les bons documents et de façonner la sortie — fondamental pour lire les données efficacement.

## find — interroger les documents

```js
db.users.find();                          // all documents
db.users.find({ age: { $gt: 25 } });      // filter: matching documents (a CURSOR)
db.users.findOne({ email: "ann@x.com" }); // the FIRST matching document (or null)

// find returns a CURSOR you can chain methods on
db.users.find({ active: true })
  .sort({ name: 1 })                      // sort
  .limit(10)                              // limit
  .skip(20);                              // skip (pagination)
```

`find` retourne un **cursor** (un pointeur vers les résultats) que vous pouvez enchaîner avec `sort`, `limit`, `skip`, etc. `findOne` retourne un seul document directement.

## Projection — choisir les champs à retourner

```js
// projection: 1 = include, 0 = exclude
db.users.find({ active: true }, { name: 1, email: 1 });        // only name and email (+ _id)
db.users.find({}, { password: 0 });                           // everything EXCEPT password
db.users.find({}, { name: 1, _id: 0 });                       // name only, exclude _id
```

**Projection** (le deuxième argument) contrôle les champs retournés : `1` inclut, `0` exclut. `_id` est inclus par défaut (excluez-le avec `_id: 0`). Vous ne pouvez généralement pas mélanger les inclusions et les exclusions (sauf pour `_id`).

## Pourquoi c'est important : efficacité et sécurité

```text
✓ EFFICIENCY — return only needed fields → less data transferred (especially for large
  documents or large result sets) → faster
✓ SECURITY — EXCLUDE sensitive fields (passwords, internal data) so they don't leak
  → e.g. always project out password fields when returning user data
```

## Projeter les champs imbriqués et les tableaux

```js
db.users.find({}, { "address.city": 1 });        // nested field (dot notation)
db.posts.find({}, { comments: { $slice: 5 } });   // first 5 array elements
```

## Pourquoi c'est important

`find` et la projection sont fondamentales pour **lire les données** dans MongoDB — interroger les bons documents et façonner la sortie sont des besoins constants, donc comprendre cela est une connaissance essentielle du quotidien.

Savoir comment `find` fonctionne (retournant un cursor de documents correspondants, enchaînable avec `sort`/`limit`/`skip` pour l'ordre et la pagination) et `findOne` (un seul document) est la base de la lecture de données. **Projection** est particulièrement importante pour deux raisons pratiques : **efficacité** (retourner uniquement les champs dont vous avez besoin réduit les données transférées — significatif pour les gros documents ou les jeux de résultats, améliorant la performance) et surtout **sécurité** (exclure les champs sensibles comme les mots de passe ou les données internes pour qu'ils ne fuient pas dans les résultats de requête — une pratique courante et importante, par ex. toujours exclure les champs de mot de passe lors du retour de données utilisateur, similaire à l'utilisation de modèles de réponse dans les API).

Savoir comment inclure (`1`) ou exclure (`0`) des champs, que `_id` soit inclus par défaut, et comment projeter les champs imbriqués/tableaux couvre la mise en forme pratique des résultats de requête.

Comme la lecture de données est l'opération de base de données la plus courante, et comme `find` avec projection est la façon dont vous récupérez efficacement et en toute sécurité les bons documents avec les bons champs, comprendre les requêtes find et les projections — le modèle de cursor, l'enchaînement pour le tri/pagination, et surtout la projection pour l'efficacité et la sécurité (exclure les données sensibles) — est une connaissance MongoDB essentielle, fréquemment appliquée pour tout code de lecture de données, l'aspect sécurité de l'exclusion des données sensibles étant une considération pratique particulièrement importante.