Bagaimana cara kerja query find dan projection?

Question

Accepted Answer

Metode **`find`** mengambil dokumen yang cocok dengan filter; **projection** mengontrol field mana yang dikembalikan. Bersama-sama, keduanya memungkinkan Anda melakukan query untuk dokumen yang tepat dan membentuk output — fundamental untuk membaca data secara efisien.

## find — query dokumen

```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` mengembalikan **cursor** (pointer ke hasil) yang dapat Anda rantai dengan `sort`, `limit`, `skip`, dll. `findOne` mengembalikan satu dokumen secara langsung.

## Projection — pilih field mana yang dikembalikan

```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** (argument kedua) mengontrol field yang dikembalikan: `1` menyertakan, `0` mengecualikan. `_id` disertakan secara default (dikecualikan dengan `_id: 0`). Anda umumnya tidak dapat mencampur include dan exclude (kecuali untuk `_id`).

## Mengapa ini penting: efisiensi dan keamanan

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

## Memproyeksikan field nested dan array

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

## Mengapa ini penting

`find` dan projection adalah fundamental untuk **membaca data** di MongoDB — melakukan query untuk dokumen yang tepat dan membentuk output adalah kebutuhan konstan, jadi memahami keduanya adalah pengetahuan dasar yang esensial.

Memahami cara kerja `find` (mengembalikan cursor dari dokumen yang cocok, dapat dirantai dengan `sort`/`limit`/`skip` untuk pengurutan dan paginasi) dan `findOne` (satu dokumen) adalah fondasi membaca data. **Projection** sangat penting karena dua alasan praktis: **efisiensi** (mengembalikan hanya field yang Anda butuhkan mengurangi data yang ditransfer — signifikan untuk dokumen besar atau set hasil yang besar, meningkatkan performa) dan terutama **keamanan** (mengecualikan field sensitif seperti password atau data internal agar tidak bocor dalam hasil query — praktik umum dan penting, misalnya selalu memproyeksikan keluar field password saat mengembalikan data pengguna, mirip dengan menggunakan response model dalam API).

Memahami cara menyertakan (`1`) atau mengecualikan (`0`) field, bahwa `_id` disertakan secara default, dan cara memproyeksikan field nested/array mencakup pembentukan praktis hasil query.

Karena membaca data adalah operasi database yang paling umum, dan karena `find` dengan projection adalah cara Anda mengambil dokumen yang tepat dengan field yang tepat secara efisien dan aman, memahami query find dan projection — model cursor, rantai untuk sort/paginasi, dan terutama projection untuk efisiensi dan keamanan (mengecualikan data sensitif) — adalah pengetahuan MongoDB yang esensial dan sering diterapkan untuk kode pembacaan data apa pun, dengan aspek keamanan memproyeksikan field sensitif menjadi pertimbangan praktis yang sangat penting.