find sorguları ve projeksiyonları nasıl çalışır?

Question

Accepted Answer

The **`find`** method retrieves documents matching a filter; **projection** controls which fields are returned. Together they let you query for the right documents and shape the output — fundamental for reading data efficiently.

## find — query documents

```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` returns a **cursor** (a pointer to results) you can chain with `sort`, `limit`, `skip`, etc. `findOne` returns a single document directly.

## Projection — choose which fields to return

```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** (the second argument) controls returned fields: `1` includes, `0` excludes. `_id` is included by default (exclude with `_id: 0`). You generally can't mix includes and excludes (except for `_id`).

## Why projection matters: efficiency and security

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

## Projecting nested and array fields

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

## Neden önemli

`find` ve projection MongoDB'de **verileri okumak** için temeldir — doğru belgeler için sorgu yapma ve çıktıyı şekillendirme sürekli ihtiyaçlar olduğundan, bunları anlamak essential günlük bilgidir.

`find`'ın nasıl çalıştığını bilmek (eşleşen belgelerin cursor'ünü döndürme, `sort`/`limit`/`skip` ile zincirleme yapılabilir sıralama ve pagination için) ve `findOne` (tek bir belge) veri okuma temelini oluşturur. **Projection** özellikle iki pratik nedenden dolayı önemlidir: **verimlilik** (ihtiyacınız olan alanları döndürmek aktarılan veri miktarını azaltır — büyük belgeler veya sonuç kümeleri için önemlidir, performansı iyileştirir) ve özellikle **güvenlik** (parolalar veya dahili veriler gibi hassas alanları hariç tutarak sorgu sonuçlarında sızmamalarını sağlama — yaygın, önemli bir uygulama, örn. kullanıcı verilerini döndürürken her zaman parola alanlarını projection'dan çıkarmak, API'lerde response modellerini kullanmaya benzer).

Alanları dahil etmeyi (`1`) veya hariç tutmayı (`0`), `_id`'nin varsayılan olarak dahil edildiğini ve nested/array alanları projection'dan çıkarmayı anlamak, sorgu sonuçlarının pratik şeklendirilmesini kapsar.

Veri okuma en yaygın veritabanı işlemi olduğundan ve `find` with projection'ın etkili ve güvenli bir şekilde doğru alanlarla doğru belgeleri almanın yolu olduğundan, find sorgularını ve projeksiyonları anlamak — cursor modeli, sort/pagination için zincirleme ve özellikle verimlilik ve güvenlik için projection (hassas verileri hariç tutma) — herhangi bir veri okuma kodu için essential, sık kullanılan MongoDB bilgisidir, projection ile hassas alanları hariç tutmanın güvenlik yönü özellikle önemli pratik bir husustur.