Hvordan fungerer find-forespørgsler og projektioner?

Question

Accepted Answer

Metoden **`find`** henter dokumenter, der matcher et filter; **projektion** styrer, hvilke felter der returneres. Sammen giver de dig mulighed for at forespørge efter de rigtige dokumenter og forme outputtet — fundamentalt for at læse data effektivt.

## find — forespørg dokumenter

```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` returnerer en **cursor** (en pointer til resultater), som du kan kæde sammen med `sort`, `limit`, `skip` osv. `findOne` returnerer et enkelt dokument direkte.

## Projektion — vælg hvilke felter der skal returneres

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

**Projektion** (det andet argument) styrer returnerede felter: `1` inkluderer, `0` ekskluderer. `_id` er inkluderet som standard (ekskluder med `_id: 0`). Du kan generelt ikke blande inkluderinger og ekskluderinger (undtagen for `_id`).

## Hvorfor projektion betyder noget: effektivitet og sikkerhed

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

## Projicering af indlejrede og array-felter

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

## Hvorfor det betyder noget

`find` og projektion er fundamentale for **at læse data** i MongoDB — at forespørge efter de rigtige dokumenter og forme outputtet er konstante behov, så forståelse af dem er væsentlig hverdagsviden.

At vide, hvordan `find` fungerer (returnerer en cursor af matchende dokumenter, kan kædes sammen med `sort`/`limit`/`skip` til sortering og paginering) og `findOne` (et enkelt dokument) er grundlaget for at læse data. **Projektion** er særligt vigtig af to praktiske årsager: **effektivitet** (at returnere kun de felter, du har brug for, reducerer data overført — betydeligt for store dokumenter eller resultat-sæt, forbedrer ydeevne) og især **sikkerhed** (ekskluderer følsomme felter som adgangskoder eller interne data, så de ikke lækker i forespørgselsresultater — en almindelig, vigtig praksis, f.eks. altid ekskluderer adgangskode-felter ved returnering af brugerdata, svarende til at bruge response-modeller i API'er).

At forstå, hvordan man inkluderer (`1`) eller ekskluderer (`0`) felter, at `_id` er inkluderet som standard, og hvordan man projicerer indlejrede/array-felter, dækker den praktiske formning af forespørgselsresultater.

Fordi dataleseneng er den mest almindelige databaseoperation, og fordi `find` med projektion er, hvordan du effektivt og sikkert henter de rigtige dokumenter med de rigtige felter, er forståelse af find-forespørgsler og projektioner — cursor-modellen, kæding for sortering/paginering, og især projektion for effektivitet og sikkerhed (ekskluderer følsomme data) — væsentlig, hyppigt anvendt MongoDB-viden for enhver data-læsende kode, hvor sikkerhedsaspektet af at projicere følsomme felter ud er en særlig vigtig praktisk overvejelse.