MongoDB Academy · पाठ

$elemMatch: ऐरे के उप-दस्तावेज़ों का मिलान

शिक्षार्थी एक ही ऐरे तत्व पर कई शर्तें लागू करने के लिए $elemMatch का उपयोग करेंगे और अलग-अलग फ़ील्ड में फैले मिलान से होने वाले गलत सकारात्मक परिणामों से बचेंगे।

पाठ 2, कुल 4 में से13 चरण

$elemMatch: ऐरे के उप-दस्तावेज़ों का मिलान, CoddyKit पर MongoDB Academy का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह MongoDB Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। MongoDB Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

उप-दस्तावेज़ ऐरे पैटर्न

MongoDB में मूल दस्तावेज़ के अंदर एम्बेड किए गए उप-दस्तावेज़ों—अर्थात कई फ़ील्ड वाली ऑब्जेक्ट—के ऐरे संग्रहीत करना आम है। उदाहरणों में लाइन आइटम वाले ऑर्डर, कई पतों वाले उपयोगकर्ता या विषय-वार अंकों वाले विद्यार्थी शामिल हैं। इन संरचनाओं पर क्वेरी करते समय सावधानी आवश्यक है, ताकि फैले हुए फ़ील्ड की समस्या न हो, जिसमें शर्तों का मिलान अलग-अलग ऐरे तत्वों में हो जाता है।

// Example: student with per-subject scores
db.students.insertMany([
  {
    name: 'Alice',
    scores: [
      { subject: 'math', score: 95, grade: 'A' },
      { subject: 'english', score: 72, grade: 'C' }
    ]
  },
  {
    name: 'Bob',
    scores: [
      { subject: 'math', score: 68, grade: 'D' },
      { subject: 'english', score: 91, grade: 'A' }
    ]
  }
]);

फैले हुए फ़ील्ड की समस्या फिर से

जब आप डॉट-नोटेशन वाले फ़ील्ड का सीधे उपयोग करके उप-दस्तावेज़ों के ऐरे को फ़िल्टर करते हैं, तो MongoDB प्रत्येक शर्त को ऐरे के किसी भी तत्व पर स्वतंत्र रूप से लागू करता है। क्वेरी { 'scores.subject': 'math', 'scores.grade': 'A' } किसी दस्तावेज़ से तब मेल खाएगी, जब किसी भी तत्व का विषय='math' और किसी भी (संभवतः अलग) तत्व का ग्रेड='A' हो। यह गलत-सकारात्मक व्यवहार फैले हुए फ़ील्ड की समस्या है।

// Problematic query - spread field issue
db.students.find({
  'scores.subject': 'math',
  'scores.grade': 'A'
});
// Returns BOTH Alice AND Bob!
// Alice: scores[0] has subject='math', scores[0] has grade='A' -> correct match
// Bob:   scores[0] has subject='math' + scores[1] has grade='A' -> false positive!

$elemMatch फैली हुई समस्या हल करता है

$elemMatch इसका समाधान है: यह सभी शर्तों को एक ही ऐरे तत्व पर पूरा होने के लिए सीमित करता है। MongoDB केवल तभी कोई दस्तावेज़ लौटाता है, जब ऐरे का कम-से-कम एक तत्व $elemMatch ब्लॉक के अंदर मौजूद प्रत्येक शर्त को एक साथ पूरा करता हो। कई शर्तों वाले उप-दस्तावेज़ों के ऐरे पर क्वेरी करने का यही सही तरीका है।

// Correct query with $elemMatch
db.students.find({
  scores: {
    $elemMatch: {
      subject: 'math',
      grade: 'A'
    }
  }
});
// Returns ONLY Alice (scores[0] has BOTH subject='math' AND grade='A')
// Bob is excluded: no single element satisfies both conditions

$elemMatch के अंदर सीमा ऑपरेटरों का उपयोग

आप $elemMatch के अंदर किसी भी MongoDB क्वेरी ऑपरेटर का उपयोग कर सकते हैं, जिनमें $gt, $lte और $in जैसे सीमा ऑपरेटर भी शामिल हैं। इससे आप ऐसी शर्तें लिख सकते हैं: 'ऐसा कोई तत्व ढूँढें जिसका स्कोर 80 और 100 के बीच हो तथा विषय गणित हो'—दोनों शर्तें एक ही विशिष्ट तत्व के लिए सत्य होनी चाहिए।

// Find students with a math score above 80
db.students.find({
  scores: {
    $elemMatch: {
      subject: 'math',
      score: { $gt: 80 }
    }
  }
});
// Returns Alice (math score is 95 > 80)

// With $in inside $elemMatch
db.students.find({
  scores: {
    $elemMatch: {
      subject: { $in: ['math', 'science'] },
      grade: 'A'
    }
  }
});

$elemMatch के परिणामों को नकारना

किसी ऐसी शर्त वाले दस्तावेज़ों को ढूँढने के लिए, जिन्हें ऐरे का कोई भी तत्व पूरा न करता हो, आप $not का उपयोग करके $elemMatch की शर्त को नकार सकते हैं। उदाहरण के लिए, 'ऐसे विद्यार्थियों को ढूँढें जिनके पास गणित में A न हो' का अर्थ है कि कोई भी तत्व subject=math और grade=A दोनों को पूरा न करता हो। यह { 'scores.grade': { $ne: 'A' } } जाँचने से अधिक सटीक है, क्योंकि वह किसी भी A-ग्रेड वाले विषय के विद्यार्थियों को बाहर कर देगी।

// Students who do NOT have a math A
db.students.find({
  scores: {
    $not: {
      $elemMatch: {
        subject: 'math',
        grade: 'A'
      }
    }
  }
});
// Returns Bob (his math score is D, not A)

प्रोजेक्शन में $elemMatch

किसी शर्त से मेल खाने वाले ऐरे के केवल पहले तत्व को लौटाने के लिए $elemMatch का उपयोग प्रोजेक्शन (find() का दूसरा तर्क) में भी किया जा सकता है। प्रोजेक्शन में इसका उपयोग करने पर इसे $elemMatch प्रोजेक्शन ऑपरेटर कहा जाता है (नाम समान है, लेकिन संदर्भ अलग है)। यह प्रत्येक दस्तावेज़ से अधिकतम एक मेल खाने वाला तत्व लौटाता है।

// Project only the FIRST matching scores element
db.students.find(
  { name: 'Alice' },
  {
    name: 1,
    scores: {
      $elemMatch: { subject: 'math' }
    }
  }
);
// Returns:
// { name: 'Alice', scores: [{ subject: 'math', score: 95, grade: 'A' }] }
// Only the math element is included, english is excluded

$elemMatch प्रोजेक्शन बनाम $ पोज़िशनल

किसी एक मेल खाने वाले ऐरे तत्व को प्रोजेक्ट करने के दो तरीके हैं: $elemMatch प्रोजेक्शन (प्रोजेक्शन ऑब्जेक्ट में) आपको क्वेरी फ़िल्टर से अलग फ़िल्टर निर्दिष्ट करने देता है, जबकि पोज़िशनल $ ऑपरेटर स्वयं क्वेरी फ़िल्टर से मेल खाने वाला पहला तत्व लौटाता है। जब क्वेरी फ़िल्टर और वह प्रोजेक्ट किया जाने वाला तत्व अलग हों, तब प्रोजेक्शन में $elemMatch का उपयोग करें।

// $ positional: returns the element matched by the query filter
db.students.find(
  { 'scores.subject': 'math' },
  { 'scores.$': 1 }
);

// $elemMatch projection: different filter from query
db.students.find(
  { name: 'Alice' },  // query doesn't filter scores
  { scores: { $elemMatch: { grade: 'A' } } }  // but project only A-grade scores
);

गहराई से नेस्ट किए गए ऐरे उप-दस्तावेज़

MongoDB श्रृंखलाबद्ध डॉट नोटेशन का उपयोग करके ऐरे के अंदर ऐरे और गहराई से नेस्ट किए गए उप-दस्तावेज़ों पर क्वेरी करने की सुविधा देता है। हालांकि, $elemMatch एक बार में केवल एक स्तर की गहराई पर लागू होता है। ऐरे के अंदर नेस्ट किए गए ऐरे पर क्वेरी के लिए आपको कई $elemMatch ऑपरेटरों को श्रृंखला में लगाना होगा या अत्यधिक नेस्टिंग से बचने के लिए अपनी स्कीमा की संरचना बदलनी होगी।

// Document with nested arrays
// { courses: [{ name: 'Math', lessons: [{ id: 1, score: 95 }] }] }

// Query nested array with chained dot notation
db.curriculum.find({ 'courses.lessons.score': { $gt: 90 } });

// More precise with $elemMatch (one level)
db.curriculum.find({
  courses: {
    $elemMatch: {
      name: 'Math',
      'lessons.score': { $gt: 90 }  // dot notation within $elemMatch
    }
  }
});

$elemMatch क्वेरी के लिए इंडेक्स बनाना

ऐरे फ़ील्ड पर मौजूद मल्टीकी इंडेक्स $elemMatch क्वेरी का समर्थन करता है। MongoDB इंडेक्स किए गए फ़ील्ड मानों के आधार पर संभावित दस्तावेज़ों की संख्या कम करने के लिए इंडेक्स का उपयोग करता है, फिर प्रत्येक संभावित दस्तावेज़ की पुष्टि करने के लिए पूरी $elemMatch शर्त लागू करता है। इंडेक्स की दक्षता अधिकतम करने के लिए, अपनी $elemMatch शर्त में सबसे अधिक चयनात्मक फ़ील्ड को इंडेक्स में शामिल करें।

// Index on scores.subject for efficient $elemMatch queries
db.students.createIndex({ 'scores.subject': 1 });

// This $elemMatch query can use the index to find 'math' entries,
// then applies the grade: 'A' condition on those candidates
db.students.find({
  scores: {
    $elemMatch: {
      subject: 'math',  // <-- indexed, drives the IXSCAN
      grade: 'A'        // <-- applied after index lookup
    }
  }
});

$exists और $type के साथ $elemMatch

वैकल्पिक फ़ील्ड वाले या किसी विशिष्ट BSON प्रकार से मेल खाने वाले ऐरे तत्वों को ढूँढने के लिए आप $elemMatch के अंदर $exists और $type का उपयोग कर सकते हैं। यह विषम ऐरे के लिए उपयोगी है, जहाँ सभी तत्वों की संरचना समान नहीं होती—ऐसा पुराने डेटा के माइग्रेशन या लचीली इवेंट लॉग स्कीमा में आम है।

// Find docs with at least one scores element that has a 'notes' field
db.students.find({
  scores: {
    $elemMatch: {
      notes: { $exists: true }
    }
  }
});

// Find docs with a scores element where score is a string (data quality check)
db.students.find({
  scores: {
    $elemMatch: {
      score: { $type: 'string' }  // should be a number!
    }
  }
});

वास्तविक उदाहरण: ई-कॉमर्स ऑर्डर

$elemMatch का एक व्यावहारिक उपयोग ई-कॉमर्स में है: ऐसे ऑर्डर ढूँढना जिनमें किसी विशिष्ट उत्पाद का लाइन आइटम हो और उसकी मात्रा निर्धारित सीमा से अधिक हो। $elemMatch के बिना, शर्तें अलग-अलग लाइन आइटमों में फैल जातीं और गलत-सकारात्मक परिणाम देतीं।

// Find orders containing 'product-123' with qty > 5
db.orders.find({
  lineItems: {
    $elemMatch: {
      productId: 'product-123',
      qty: { $gt: 5 }
    }
  }
});

// Also useful for status-filtered sub-documents:
db.projects.find({
  tasks: {
    $elemMatch: {
      assignee: 'alice',
      status: 'in-progress',
      priority: { $gte: 3 }
    }
  }
});

त्वरित जाँच

ऐरे के उप-दस्तावेज़ों से मिलान करने के लिए $elemMatch की अपनी समझ जाँचें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पाठ का सारांश

इस पाठ में आपने सीखा कि क्वेरी में $elemMatch के लिए सभी शर्तों का एक ही ऐरे तत्व से मेल खाना आवश्यक है, जिससे फैले हुए फ़ील्ड की समस्या हल होती है; प्रोजेक्शन में $elemMatch केवल पहला मेल खाने वाला तत्व लौटाता है; और मल्टीकी इंडेक्स $elemMatch क्वेरी का कुशलतापूर्वक समर्थन करते हैं। अब हम ऐरे अपडेट ऑपरेटरों पर चर्चा करेंगे।

शुरुआत निःशुल्क

एआई शिक्षक के साथ JavaScript सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 30
पाठ: 120

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “$elemMatch: ऐरे के उप-दस्तावेज़ों का मिलान” पाठ निःशुल्क है?

हाँ—“$elemMatch: ऐरे के उप-दस्तावेज़ों का मिलान” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और MongoDB Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। MongoDB Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“$elemMatch: ऐरे के उप-दस्तावेज़ों का मिलान” में मैं क्या सीखूँगा?

शिक्षार्थी एक ही ऐरे तत्व पर कई शर्तें लागू करने के लिए $elemMatch का उपयोग करेंगे और अलग-अलग फ़ील्ड में फैले मिलान से होने वाले गलत सकारात्मक परिणामों से बचेंगे। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ MongoDB Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या MongoDB Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर MongoDB Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“$elemMatch: ऐरे के उप-दस्तावेज़ों का मिलान” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस MongoDB Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर MongoDB Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

ऐरे पर क्वेरी: $all, $size और एलिमेंट मिलान
$elemMatch: ऐरे के उप-दस्तावेज़ों का मिलान
ऐरे अपडेट करना: $push, $pull, $pop, $addToSet
स्थितीय और फ़िल्टर किए गए स्थितीय अपडेट

← MongoDB Academy पर वापस जाएँ