The $slice operator returns a portion of an array — the first N elements, the last N elements, or a window starting at a specific position. Use it in aggregation pipelines, find projections, and capped-array updates.
Take part of array.
2 or 3 arguments.
From the end.
Limit in find().
Preview, paginate.
$push + $slice.
MongoDB’s $slice operator extracts elements from an array without modifying the original document (in read contexts). In aggregation, { $slice: [ "$comments", 3 ] } returns the first three comments. With a negative number, { $slice: [ "$comments", -2 ] } returns the last two.
This is ideal when you need a preview of a long list — recent activity, top tags, or paginated results — without transferring the entire array over the network.
Pair $slice with $size when you need both a count and a preview: use $size for the total length and $slice for the first few items.
$slice supports aggregation expressions, find projections, and update modifiers:
{ $slice: [ <array>, <n> ] }
{ $slice: [ <array>, <position>, <n> ] }{ <arrayField>: { $slice: <n> } }
{ <arrayField>: { $slice: [ <position>, <n> ] } }[ array, n ]: positive n takes from the start; negative n takes from the end.[ array, position, n ]: start at 0-based position, return n elements.$project, $addFields, or $set.[1, 2] (first two)[4, 5] (last two)[2, 3, 4] (start at index 1, take 3)[3, 4, 5] (only 3 left)| Question | Answer |
|---|---|
| Operator type | Aggregation expression, projection, and update modifier |
| Aggregation syntax | { $slice: [ arr, n ] } or [ arr, pos, n ] |
| Positive n | Elements from the start (two-arg) or count from position (three-arg) |
| Negative n (two-arg) | Last |n| elements |
| Common stages | $project, $addFields, find projection |
{
$slice: ["$tags", 3]
}Start of array
{
$slice: ["$logs", -2]
}End of array
{
$slice: ["$items", 2, 4]
}Index 2, take 4
{
comments: { $slice: 5 }
}First 5 in query
Take the first few tags, grab the latest comments, paginate with a position window, and limit arrays in find projections with $slice.
Preview the first three tags from each article using $project.
Suppose you have an articles collection:
[
{
"_id": 1,
"title": "MongoDB Tips",
"tags": ["mongodb", "database", "nosql", "aggregation", "tutorial"]
},
{
"_id": 2,
"title": "Node.js Guide",
"tags": ["nodejs", "javascript"]
},
{
"_id": 3,
"title": "Draft",
"tags": []
}
]Return only the first three tags per document:
db.articles.aggregate([
{
$project: {
title: 1,
topTags: { $slice: [ "$tags", 3 ] }
}
}
])The two-argument form with positive 3 takes elements from index 0 through 2. Shorter arrays return all available elements.
Recent comments, paginated windows, and find-query previews.
Use a negative n to take elements from the end:
db.posts.aggregate([
{
$project: {
title: 1,
recentComments: {
$slice: [ "$comments", -2 ]
}
}
}
])
// comments: ["a", "b", "c", "d", "e"]
// recentComments: ["d", "e"]Negative n counts from the end of the array. This pattern is common for “latest activity” previews.
Skip the first two items and take the next three (page-style window):
db.articles.aggregate([
{
$project: {
title: 1,
tagPage: {
$slice: [ "$tags", 2, 3 ]
}
}
}
])
// tags: ["mongodb", "database", "nosql", "aggregation", "tutorial"]
// tagPage: ["nosql", "aggregation", "tutorial"]The three-argument form uses a 0-based position and a count n. Position 2 starts at the third element.
Return only the first five comments without an aggregation pipeline:
db.posts.find(
{ _id: 1 },
{ comments: { $slice: 5 } }
)
// Returns first 5 comments only in the resultFind projection $slice limits what the client receives. The full array remains stored in the document unless you update it separately.
Keep only the last 10 comments when pushing a new one:
db.posts.updateOne(
{ _id: 1 },
{
$push: {
comments: {
$each: [ { text: "New comment", at: new Date() } ],
$slice: -10
}
}
}
)
// Appends the comment, then keeps only the last 10Combine $push, $each, and $slice to maintain a fixed-size rolling list without manual trimming.
$slice.$push + $slice.$slice WorksThe input resolves to an array field, literal, or nested expression.
Two-arg form uses start/end logic with sign of n. Three-arg form uses explicit position and length.
If fewer elements exist than requested, MongoDB returns whatever is available without error.
Use in projections, API responses, or chained with $size for totals.
The $slice operator extracts portions of arrays for previews, pagination, and capped updates. Learn both the two-argument form (first or last N) and the three-argument form (position + count).
Use aggregation $slice when building computed fields; use find projection $slice when you only need to limit returned data. Next in the series: $sortArray.
n for “latest N” previews$size to show “3 of 12” in UIs$push + $slice to cap growing arrays on update$ifNull: [ "$field", [] ] before slicing$slice with JavaScript Array.slice() argument order in three-arg form$slice modifies stored data — it only limits output$slice when you need sorted results first — sort with $sortArray before slicing$sliceUse these points when extracting array subsets in MongoDB.
Part of array.
PurposeFirst or last.
SyntaxFrom the end.
RuleWindow slice.
PaginationAgg / find / update.
ImportantMove on to $sortArray to sort array elements before slicing, or review $size for counting.
5 people found this page helpful