find queries र projections कसरी काम गर्छन्?

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

## यो किन महत्त्वपूर्ण छ

`find` र projection MongoDB मा **डेटा पढ्नु** को लागि मौलिक छन् — सही दस्तावेजहरूको लागि क्वेरी गर्नु र आउटपुट आकार दिनु निरन्तर आवश्यकताहरू हुन्, त्यसैले तिनलाई बुझ्नु आवश्यक दैनिक ज्ञान हो।

`find` कसरी काम गर्छ भन्ने कुरा बुझ्नु (मेल खाएको दस्तावेजहरूको cursor फिर्ता गर्दै, `sort`/`limit`/`skip` सँग chainable, क्रम र pagination को लागि) र `findOne` (एकल दस्तावेज) हो डेटा पढ्नुको आधार। **Projection** दुई व्यावहारिक कारणहरूको लागि विशेष गरी महत्त्वपूर्ण छ: **दक्षता** (तपाईंले आवश्यक गरेको क्षेत्रहरू मात्र फिर्ता गर्दा स्थानान्तरण गरिएको डेटा कम हुन्छ — ठूलो दस्तावेज वा नतिजा सेटको लागि महत्त्वपूर्ण, प्रदर्शन सुधार गर्दै) र विशेषतः **सुरक्षा** (पासवर्ड वा आन्तरिक डेटा जस्ता संवेदनशील क्षेत्रहरू बाहिर निकाल्दा ताकि तिनीहरू क्वेरी नतिजामा लीक नहुन् — एक सामान्य, महत्त्वपूर्ण अभ्यास, उदाहरण को लागि उपयोगकर्ता डेटा फिर्ता गर्दा पासवर्ड क्षेत्रहरू सधैँ प्रक्षेपण बाहिर गर्नु, APIs मा प्रतिक्रिया मडेलहरू प्रयोग गर्नु जस्तै)।

`1` (समावेश गर्नु) वा `0` (बाहिर निकाल्नु) क्षेत्रहरू कसरी गर्ने, `_id` पूर्वनिर्धारितबाट समावेश गरिन्छ, र nested/array क्षेत्रहरू कसरी प्रक्षेपण गर्ने भन्ने कुरा बुझ्नु क्वेरी नतिजाहरूको व्यावहारिक आकार दिनु समेट छ।

डेटा पढ्नु सबैभन्दा सामान्य डेटाबेस अपरेशन भएकोले, र `find` with projection सही दस्तावेजहरू सही क्षेत्रहरूसँग दक्षतापूर्वक र सुरक्षित रूपमा पुनः प्राप्त गर्ने तरिका भएकोले, find queries र projections — cursor मडेल, sort/pagination को लागि chaining, र विशेषतः दक्षता र सुरक्षा को लागि projection (संवेदनशील डेटा बाहिर निकाल्दा) — बुझ्नु आवश्यक छ, कुनै पनि डेटा-पढ्ने कोडको लागि बारम्बार लागू गरिएको MongoDB ज्ञान हो, संवेदनशील क्षेत्रहरू प्रक्षेपण गर्ने सुरक्षा पक्ष विशेषतः महत्त्वपूर्ण व्यावहारिक विचार भएकोले।