Bagaimanakah pertanyaan find dan projeksi berfungsi?

Question

Accepted Answer

Kaedah **`find`** mendapatkan dokumen yang memadankan penapis; **projeksi** mengawal medan mana yang dikembalikan. Bersama-sama ia membolehkan anda mempertanyakan dokumen yang betul dan membentuk output — asas untuk membaca data dengan cekap.

## find — pertanyakan 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 sebuah **kursor** (penunjuk kepada hasil) yang boleh anda rantaikan dengan `sort`, `limit`, `skip`, dll. `findOne` mengembalikan satu dokumen secara terus.

## Projeksi — pilih medan mana yang hendak 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
```

**Projeksi** (argumen kedua) mengawal medan yang dikembalikan: `1` memasukkan, `0` mengecualikan. `_id` dimasukkan secara lalai (kecualikan dengan `_id: 0`). Anda secara umumnya tidak boleh mencampurkan kemasukan dan pengecualian (kecuali untuk `_id`).

## Mengapa projeksi penting: kecekapan dan keselamatan

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

## Memprojeksikan medan bersarang dan tatasusunan

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

## Mengapa ia penting

`find` dan projeksi adalah asas untuk **membaca data** dalam MongoDB — mempertanyakan dokumen yang betul dan membentuk output ialah keperluan berterusan, jadi memahaminya ialah pengetahuan harian yang penting.

Mengetahui bagaimana `find` berfungsi (mengembalikan kursor dokumen yang memadankan, boleh dirantai dengan `sort`/`limit`/`skip` untuk pengisihan dan penomboran halaman) dan `findOne` (satu dokumen) ialah asas membaca data. **Projeksi** sangat penting atas dua sebab praktikal: **kecekapan** (mengembalikan hanya medan yang anda perlukan mengurangkan data yang dipindahkan — ketara untuk dokumen besar atau set hasil, meningkatkan prestasi) dan terutamanya **keselamatan** (mengecualikan medan sensitif seperti kata laluan atau data dalaman supaya ia tidak bocor dalam hasil pertanyaan — amalan biasa yang penting, contohnya sentiasa memprojeksikan keluar medan kata laluan apabila mengembalikan data pengguna, serupa dengan menggunakan model respons dalam API).

Memahami cara memasukkan (`1`) atau mengecualikan (`0`) medan, bahawa `_id` dimasukkan secara lalai, dan cara memprojeksikan medan bersarang/tatasusunan merangkumi pembentukan praktikal hasil pertanyaan.

Memandangkan membaca data ialah operasi pangkalan data yang paling biasa, dan memandangkan `find` dengan projeksi ialah cara anda mendapatkan dokumen yang betul dengan medan yang betul secara cekap dan selamat, memahami pertanyaan find dan projeksi — model kursor, perantaian untuk sort/penomboran halaman, dan terutamanya projeksi untuk kecekapan dan keselamatan (mengecualikan data sensitif) — ialah pengetahuan MongoDB yang penting dan kerap digunakan untuk sebarang kod membaca data, dengan aspek keselamatan memprojeksikan keluar medan sensitif menjadi pertimbangan praktikal yang sangat penting.