MongoDB Academy · 课时

查询数组：$all、$size 和元素匹配

您将使用 $all 匹配多个数组元素，并使用 $size 检查数组长度，从而按数组内容筛选文档。

查询数组：$all、$size 和元素匹配 是 CoddyKit 上的免费 MongoDB Academy 课时。这是第 1 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 MongoDB Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 MongoDB Academy 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Arrays as First-Class Citizens

In MongoDB, arrays are a native BSON type that can be stored directly in a document field. Unlike relational databases where arrays require a separate junction table, MongoDB lets you embed arrays of any type—scalars, sub-documents, or mixed—directly in the document. This makes arrays one of the most useful features but also one of the most nuanced to query correctly.

// Documents with array fields
db.products.insertMany([
  { name: 'Laptop', tags: ['electronics', 'computers', 'portable'] },
  { name: 'Mouse', tags: ['electronics', 'peripherals'] },
  { name: 'Book', tags: ['education', 'reading'] }
]);

Simple Array Equality Queries

A simple equality filter on an array field checks whether the array contains the specified value as an element. You don't need a special operator—just write the filter as if the field were a scalar. MongoDB will match any document where the array contains that exact value anywhere in it.

// Find products tagged 'electronics'
// MongoDB checks if 'electronics' is an element of the tags array
db.products.find({ tags: 'electronics' });
// Returns Laptop and Mouse (both have 'electronics' in tags)

// This also works on arrays of numbers
db.scores.find({ values: 95 });
// Matches { values: [80, 95, 72] }

The $all Operator

The $all operator matches documents where the array contains all of the specified values, in any order. Unlike a plain equality check (which matches a single element), $all enforces that every specified element is present. Think of it as multiple AND conditions on array membership.

// Find products tagged BOTH 'electronics' AND 'portable'
db.products.find({
  tags: { $all: ['electronics', 'portable'] }
});
// Returns Laptop (has both tags)
// Does NOT return Mouse (missing 'portable')

// Order of values in $all does not matter
db.products.find({
  tags: { $all: ['portable', 'electronics'] }  // same result
});

The $size Operator

The $size operator matches documents where the array field has exactly the specified number of elements. It accepts a literal integer—you cannot use range comparisons like $gt with $size directly. For range-based length checks, use a field that stores the array length alongside the array, or use an aggregation with $where.

// Find products with exactly 3 tags
db.products.find({ tags: { $size: 3 } });
// Returns Laptop (tags has 3 elements)

// $size does NOT support ranges:
// db.products.find({ tags: { $size: { $gt: 2 } } }); // INVALID

// Workaround: store the count as a field
db.products.updateMany({}, [{ $set: { tagCount: { $size: '$tags' } } }]);
db.products.find({ tagCount: { $gt: 2 } });  // range check on stored count

Matching by Array Index

You can query by a specific position in an array using dot notation with an index number. For example, { 'scores.0': 100 } matches documents where the first element of the scores array is 100. This is useful when array order is meaningful, such as a ranked list or time-ordered sequence.

// Documents: { name: 'Alice', scores: [100, 85, 92] }
//            { name: 'Bob',   scores: [75, 88, 91] }

// Find documents where the FIRST score is 100
db.results.find({ 'scores.0': 100 });
// Returns Alice

// Find where SECOND element is greater than 85
db.results.find({ 'scores.1': { $gt: 85 } });
// Returns Bob (scores[1] = 88 > 85) and Alice (85 is NOT > 85)

The Spread Field Problem

A subtle gotcha: when you filter an array of sub-documents with multiple conditions on different fields, MongoDB applies each condition independently across all array elements—not to a single element. This is called the spread field problem. For example, { 'scores.value': { $gt: 90 }, 'scores.grade': 'A' } matches if any element has value > 90 AND any element has grade 'A'—they don't have to be the same element.

// Documents:
// { scores: [{ value: 95, grade: 'A' }, { value: 60, grade: 'D' }] }
// { scores: [{ value: 92, grade: 'B' }, { value: 72, grade: 'C' }] }

// This filter has SPREAD FIELD issue:
// Matches doc1 (value 95>90 is in scores[0], grade 'A' is in scores[0] - fine here)
// Also matches doc2 if value 92>90 from one element + some 'B'... but what if:
// { scores: [{ value: 91, grade: 'B' }, { value: 62, grade: 'A' }] }
// This would ALSO match! 91 > 90 from element[0] + grade 'A' from element[1]

$elemMatch for Multi-Condition Array Queries

The $elemMatch query operator solves the spread field problem by requiring all conditions to be satisfied by the same single array element. Wrap your conditions in { $elemMatch: { condition1, condition2 } } and MongoDB will only return documents where at least one array element satisfies all the specified conditions simultaneously.

// Find documents where a SINGLE scores element has value > 90 AND grade 'A'
db.results.find({
  scores: {
    $elemMatch: {
      value: { $gt: 90 },
      grade: 'A'
    }
  }
});
// Only matches if one element has BOTH value > 90 AND grade 'A'

$elemMatch for Scalar Arrays

$elemMatch can also be applied to arrays of scalar values (strings, numbers) when you need to apply multiple operators to the same element. For example, finding elements that are both greater than 10 and less than 20—without $elemMatch, these conditions could be satisfied by two different elements.

// Find docs where a SINGLE element is between 10 and 20
db.measurements.find({
  values: { $elemMatch: { $gt: 10, $lt: 20 } }
});
// { values: [5, 15, 25] } - matches (15 satisfies both)
// { values: [5, 30] }     - does NOT match

// Without $elemMatch (wrong - tests across elements):
db.measurements.find({ values: { $gt: 10, $lt: 20 } });
// { values: [5, 30] } WOULD match! (5 < 20, 30 > 10, different elements)

Combining $all and $elemMatch

You can use $all with $elemMatch expressions inside it to require multiple complex conditions across multiple distinct array elements. Each $elemMatch inside $all must be satisfied by a different element. This pattern is rarely needed but is available for complex multi-condition, multi-element requirements.

// Find docs where:
// - one element satisfies { value: { $gt: 90 }, grade: 'A' }
// - AND another element satisfies { value: { $lt: 70 }, grade: 'D' }
db.results.find({
  scores: {
    $all: [
      { $elemMatch: { value: { $gt: 90 }, grade: 'A' } },
      { $elemMatch: { value: { $lt: 70 }, grade: 'D' } }
    ]
  }
});

Arrays and Index Behaviour

An index on an array field automatically becomes a multikey index in MongoDB, with one index entry per array element. This means queries like { tags: 'electronics' } and { tags: { $all: ['electronics', 'portable'] } } both benefit from the index. However, a compound index cannot have multikey on more than one array field per document—attempting to do so throws an error.

// Index on tags field becomes multikey automatically
db.products.createIndex({ tags: 1 });

// These queries all use the multikey index efficiently:
db.products.find({ tags: 'electronics' });
db.products.find({ tags: { $all: ['electronics', 'portable'] } });
db.products.find({ tags: { $size: 3 } });
// Note: $size cannot use the index for size filtering
// (it still needs to check document-level array length)

Using explain() With Array Queries

Array queries with $all and $elemMatch can sometimes surprise you with their index usage. Always verify with explain('executionStats'). A $size filter will show IXSCAN on the multikey index but still examine all index entries (since size is not stored in the index). An $elemMatch on indexed fields will use IXSCAN on the matching element conditions.

// Check how array queries use indexes
db.products.find({
  tags: { $all: ['electronics', 'portable'] }
}).explain('executionStats');

// Look for:
// stage: 'IXSCAN' - index is being used
// totalKeysExamined vs nReturned ratio

Quick Check

Test your understanding of array query operators in MongoDB.

Lesson Recap

In this lesson you learned: $all requires an array to contain all specified values, $size matches arrays with an exact number of elements, and $elemMatch ensures multiple conditions apply to the same single array element, solving the spread field problem. Next up we dive deeper into $elemMatch for matching array sub-documents.

常见问题解答

「查询数组：$all、$size 和元素匹配」课时是免费的吗？

是的 — 「查询数组：$all、$size 和元素匹配」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 MongoDB Academy 课程的其余内容，请升级到 CoddyKit PRO。 MongoDB Academy 课程共包含 4 节课。

「查询数组：$all、$size 和元素匹配」这节课中我会学到什么？

您将使用 $all 匹配多个数组元素，并使用 $size 检查数组长度，从而按数组内容筛选文档。你通过在浏览器中直接运行的动手代码来练习 MongoDB Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 MongoDB Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 MongoDB Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 1 节课，共 4 节。

「查询数组：$all、$size 和元素匹配」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 MongoDB Academy 课中编写并运行代码吗？

能。每节 MongoDB Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 MongoDB Academy