How do the $slice and $elemMatch projection operators limit which array elements are returned?

## The problem these solve A document may embed a large array — a product's reviews, a thread's comments, a device's readings. Returning the whole array to show three of its elements wastes bandwidth and client memory, and can push a document uncomfortably close to the 16 MB BSON limit when several such documents come back at once. MongoDB's `find()` projection therefore offers array-shaping operators that return a subset of an array's elements. The crucial framing: these are **projection** operators. They change the shape of what comes back; they never change which documents match. Selecting documents is the filter's job. ## $slice — positional windows `$slice` takes elements by position, ignoring their content, in three forms: ```javascript db.posts.find({}, { comments: { $slice: 5 } }) // first 5 db.posts.find({}, { comments: { $slice: -5 } }) // last 5 db.posts.find({}, { comments: { $slice: [20, 10] } }) // skip 20, take 10 ``` A positive number takes from the front, a negative number from the back. The two-element array form is `[skipCount, limitCount]`; a negative skip counts back from the end of the array. If the array is shorter than requested, you get what exists rather than an error, and if the field is not an array, `$slice` leaves it alone. This makes `$slice` the natural tool for paging a *bounded* embedded array — the latest few comments on a post, the last ten status transitions on an order. It is not a substitute for a real collection: the whole document is still read from storage and the whole array still lives in memory server-side, so slicing a 100,000-element embedded array is a design smell rather than an optimization. Bounded arrays are the precondition. ## $elemMatch in a projection — condition-based, first match only ```javascript db.students.find( { "grades.subject": "math" }, { name: 1, grades: { $elemMatch: { subject: "math" } } } ) ``` The returned `grades` is a one-element array containing the **first** element (in stored array order) whose sub-document matches `{subject: "math"}`. If the document has three math grades, you still get one. If no element matches, the `grades` field is omitted from that result document entirely — client code must handle its absence, not just an empty array. It is worth separating the two `$elemMatch` roles that share a name. In a **filter**, `$elemMatch` asks whether a single array element satisfies several conditions at once, and it selects whole documents. In a **projection**, it selects which element of an already-matched document to return. They are frequently used together, and their conditions do not have to be the same. ## The positional $ projection ```javascript db.students.find( { "grades.subject": "math" }, { name: 1, "grades.$": 1 } ) ``` The positional `$` returns the first array element that matched the **query's** condition on that array. It therefore requires the array field to appear in the filter, and it cannot express a condition of its own. `$elemMatch` is the more flexible of the two because its condition is independent — you can match documents on one criterion and pull back an element chosen by another. Both share the first-match-only limitation, and both return at most one element. ## When one element is not enough If you need *all* matching elements, no `find()` projection will do it. Use the aggregation framework's `$filter` expression: ```javascript db.students.aggregate([ { $match: { "grades.subject": "math" } }, { $project: { name: 1, grades: { $filter: { input: "$grades", as: "g", cond: { $eq: ["$$g.subject", "math"] } } } } } ]) ``` This is the single most common correction to make in a code review of array projections: someone reached for `$elemMatch` expecting a filtered array and silently shipped only the first hit. ## Interaction with the projection mode rule A projection is either inclusion or exclusion, and the array operators sit most naturally inside an inclusion projection alongside plain `1`s. `{name: 1, grades: {$elemMatch: {...}}}` reads unambiguously: return name, and return one matching grade. Mixing an array operator into an exclusion projection is confusing at best; keep the plain fields setting the mode. ## Sorting inside the array Neither operator sorts. `$slice: -5` gives you the last five elements *as stored*, which is only "the five newest" if writes append in time order — for example via `$push`. If order matters, either maintain the order on write (an appending `$push`, or `$push` with `$sort` and `$slice` modifiers to keep a capped, sorted array) or sort in an aggregation with `$sortArray`. Assuming the stored order matches business order is a quiet source of wrong answers. ## What to say in an interview Name the three `$slice` forms, state that `$elemMatch` projection is condition-based and returns only the first match (and omits the field on no match), contrast it with the positional `$` which reuses the query condition, and finish with `$filter` as the way to get every matching element.