Come funzionano le query find e le proiezioni?

Question

Accepted Answer

Il metodo **`find`** recupera i documenti che corrispondono a un filtro; la **proiezione** controlla quali campi vengono restituiti. Insieme permettono di cercare i documenti giusti e modellare l'output — fondamentale per leggere i dati in modo efficiente.

## find — eseguire query su documenti

```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` restituisce un **cursor** (un puntatore ai risultati) che puoi concatenare con `sort`, `limit`, `skip`, ecc. `findOne` restituisce un singolo documento direttamente.

## Proiezione — scegliere quali campi restituire

```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
```

La **proiezione** (il secondo argomento) controlla i campi restituiti: `1` include, `0` esclude. `_id` è incluso per impostazione predefinita (escludilo con `_id: 0`). Generalmente non puoi mescolare include ed esclude (tranne per `_id`).

## Perché è importante

```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
```

## Proiezione di campi annidati e array

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

## Perché è importante

`find` e la proiezione sono fondamentali per **leggere i dati** in MongoDB — cercare i documenti giusti e modellare l'output sono esigenze costanti, quindi comprenderli è una conoscenza essenziale di ogni giorno.

Sapere come funziona `find` (restituisce un cursor di documenti corrispondenti, concatenabile con `sort`/`limit`/`skip` per ordinamento e paginazione) e `findOne` (un singolo documento) è la base della lettura dei dati. La **proiezione** è particolarmente importante per due ragioni pratiche: **efficienza** (restituire solo i campi di cui hai bisogno riduce i dati trasferiti — significativo per documenti grandi o set di risultati, migliorando le prestazioni) e soprattutto **sicurezza** (escludere campi sensibili come password o dati interni in modo che non si infiltrino nei risultati delle query — una pratica comune e importante, ad es. escludere sempre i campi password quando si restituiscono i dati utente, simile all'uso di response model nelle API).

Capire come includere (`1`) o escludere (`0`) campi, che `_id` è incluso per impostazione predefinita, e come proiettare campi annidati/array copre la modellazione pratica dei risultati delle query.

Poiché leggere i dati è l'operazione database più comune, e poiché `find` con proiezione è il modo in cui recuperi in modo efficiente e sicuro i documenti giusti con i campi giusti, comprendere le query find e le proiezioni — il modello cursor, la concatenazione per sort/paginazione, e soprattutto la proiezione per efficienza e sicurezza (escludere dati sensibili) — è una conoscenza MongoDB essenziale e frequentemente applicata per qualsiasi codice di lettura dei dati, con l'aspetto della sicurezza nel proiettare campi sensibili essendo una considerazione pratica particolarmente importante.