Como funcionam as consultas find e as projeções?

Question

Accepted Answer

O método **`find`** recupera documentos que correspondem a um filtro; **projeção** controla quais campos são retornados. Juntos, eles permitem consultar os documentos corretos e moldar a saída — fundamental para ler dados de forma eficiente.

## find — consultar documentos

```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` retorna um **cursor** (um ponteiro para resultados) que você pode encadear com `sort`, `limit`, `skip`, etc. `findOne` retorna um único documento diretamente.

## Projeção — escolher quais campos retornar

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

**Projeção** (o segundo argumento) controla campos retornados: `1` inclui, `0` exclui. `_id` é incluído por padrão (exclua com `_id: 0`). Você geralmente não pode misturar inclusões e exclusões (exceto para `_id`).

## Por que isso importa: eficiência e segurança

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

## Projetando campos aninhados e de array

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

## Por que isso importa

`find` e projeção são fundamentais para **ler dados** no MongoDB — consultar os documentos certos e moldar a saída são necessidades constantes, portanto compreendê-los é conhecimento essencial do dia a dia.

Saber como `find` funciona (retornando um cursor de documentos correspondentes, encadeável com `sort`/`limit`/`skip` para ordenação e paginação) e `findOne` (um único documento) é a base da leitura de dados. **Projeção** é particularmente importante por duas razões práticas: **eficiência** (retornar apenas os campos necessários reduz dados transferidos — significativo para documentos grandes ou conjuntos de resultados, melhorando o desempenho) e especialmente **segurança** (excluindo campos sensíveis como senhas ou dados internos para que não vazem nos resultados de consultas — uma prática comum e importante, por exemplo, sempre projetando campos de senha quando retornando dados de usuário, semelhante ao uso de modelos de resposta em APIs).

Compreender como incluir (`1`) ou excluir (`0`) campos, que `_id` é incluído por padrão, e como projetar campos aninhados/array cobre a moldagem prática dos resultados de consultas.

Como ler dados é a operação de banco de dados mais comum, e como `find` com projeção é como você recupera de forma eficiente e segura os documentos certos com os campos certos, compreender consultas find e projeções — o modelo de cursor, encadeamento para sort/paginação, e especialmente projeção para eficiência e segurança (excluindo dados sensíveis) — é conhecimento essencial do MongoDB, frequentemente aplicado, para qualquer código de leitura de dados, sendo o aspecto de segurança de projetar dados sensíveis uma consideração prática particularmente importante.