$slice modifier with $push in MongoDB - Step-by-Step Execution

Concept Flow - $slice modifier with $push

Start with existing array

↓

Apply $push to add element

↓

Apply $slice to trim array

↓

Update document with new array

↓

End with modified array

This flow shows how MongoDB adds an element to an array and then trims it using $slice to keep only a certain number of elements.

Execution Sample

MongoDB

db.collection.updateOne(
  { _id: 1 },
  { $push: { scores: { $each: [85], $slice: -3 } } }
)

Adds 85 to the 'scores' array and keeps only the last 3 elements.

Execution Table

Step	Existing Array	Operation	Array After Operation	Explanation
1	[70, 80]	Start	[70, 80]	Initial array in document
2	[70, 80]	$push 85	[70, 80, 85]	Added 85 to the end
3	[70, 80, 85]	$slice -3	[70, 80, 85]	Array length is 3, no trimming needed
4	[70, 80, 85]	Update document	[70, 80, 85]	Document updated with new array
5	[70, 80, 85]	Next $push 90	[70, 80, 85, 90]	Added 90 to the end
6	[70, 80, 85, 90]	$slice -3	[80, 85, 90]	Trimmed to last 3 elements
7	[80, 85, 90]	Update document	[80, 85, 90]	Document updated with trimmed array
8	[80, 85, 90]	End	[80, 85, 90]	Final array after operations

💡 No more operations; array trimmed to last 3 elements after each push

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	After Step 6	Final
scores	[70, 80]	[70, 80, 85]	[70, 80, 85]	[70, 80, 85, 90]	[80, 85, 90]	[80, 85, 90]

Key Moments - 2 Insights

Why does the array get trimmed after adding a new element?

Because the $slice modifier limits the array size after $push, keeping only the specified number of elements (last 3 here), as shown in steps 3 and 6.

What happens if the array is shorter than the $slice limit before pushing?

The array stays the same length after $push if it doesn't exceed the $slice limit, as in step 3 where the array was 3 elements and $slice -3 kept all.

Visual Quiz - 3 Questions

Look at the execution table, what is the array after step 2?

A [70, 80, 85]

B [70, 80]

C [80, 85]

D [85]

💡 Hint

Check the 'Array After Operation' column for step 2 in the execution_table.

At which step does the array first get trimmed by $slice?

A Step 3

B Step 4

C Step 6

D Step 7

💡 Hint

Look for the first step where the array length decreases after $slice in the execution_table.

If we change $slice to -2, what would be the array after step 6?

A [80, 85, 90]

B [85, 90]

C [70, 80]

D [90]

💡 Hint

Refer to variable_tracker and understand $slice -2 keeps last 2 elements.

Concept Snapshot

$push with $slice adds elements to an array and trims it.
Syntax: {$push: {field: {$each: [values], $slice: n}}}
$slice: positive n keeps first n elements, negative n keeps last n.
Useful to limit array size after adding new items.
Example: $slice: -3 keeps last 3 elements after push.

Full Transcript

This visual execution shows how MongoDB's $push operator combined with the $slice modifier works. We start with an array [70, 80]. When we push 85, the array becomes [70, 80, 85]. Applying $slice: -3 keeps the last 3 elements, so the array stays the same. Next, pushing 90 makes the array [70, 80, 85, 90]. Applying $slice: -3 trims it to [80, 85, 90]. The document updates reflect these changes. This process helps keep arrays at a fixed size by trimming after adding new elements.

Practice

1. What does the $slice modifier do when used with $push in MongoDB?

easy

A. Duplicates the array elements before pushing new ones

B. Removes all elements from the array before adding new ones

C. Limits the size of the array after adding new elements

D. Sorts the array elements in ascending order

Solution

1. Step 1: Understand $push behavior

   $push adds new elements to an array field in a document.

2. Step 2: Role of $slice modifier

   $slice limits the array size after pushing, keeping only a specified number of elements.

3. Final Answer:

   Limits the size of the array after adding new elements -> Option C

4. Quick Check:

   $slice limits array size [OK]

Hint: Remember: $slice trims array size after $push [OK]

Common Mistakes:

• Thinking $slice removes elements before pushing
• Confusing $slice with sorting or duplicating
• Assuming $slice adds elements instead of limiting

2. Which of the following is the correct syntax to push multiple items and limit the array size to 3 using $slice in MongoDB?

easy

A. { $push: { scores: { $each: [90, 85], $slice: 3 } } }

B. { $push: { scores: { $slice: [3], $each: [90, 85] } } }

C. { $push: { scores: { $each: 3, $slice: [90, 85] } } }

D. { $push: { scores: { $slice: [90, 85], $each: 3 } } }

Solution

1. Step 1: Identify correct order of modifiers

   The $each modifier must come before $slice inside $push.

2. Step 2: Validate syntax correctness

   { $push: { scores: { $each: [90, 85], $slice: 3 } } } correctly uses $each: [90, 85] followed by $slice: 3 to limit array size.

3. Final Answer:

   { $push: { scores: { $each: [90, 85], $slice: 3 } } } -> Option A

4. Quick Check:

   $each before $slice [OK]

Hint: Put $each before $slice inside $push [OK]

Common Mistakes:

• Swapping order of $each and $slice
• Using arrays instead of numbers for $slice
• Placing $slice outside $push

3. Given the document { _id: 1, items: [1, 2, 3, 4] }, what will be the items array after running this update?
db.collection.updateOne({ _id: 1 }, { $push: { items: { $each: [5, 6], $slice: -4 } } })

medium

A. [3, 4, 5, 6]

B. [1, 2, 3, 4, 5, 6]

C. [2, 3, 4, 5]

D. [5, 6]

Solution

1. Step 1: Understand $each and $slice with negative value

   $each adds [5, 6] to the array. $slice: -4 keeps the last 4 elements of the array.

2. Step 2: Calculate new array content

   Original array: [1, 2, 3, 4]
   After push: [1, 2, 3, 4, 5, 6]
   Apply $slice: -4: keep last 4 elements -> [3, 4, 5, 6]

3. Final Answer:

   [3, 4, 5, 6] -> Option A

4. Quick Check:

   Negative $slice keeps last elements [OK]

Hint: Negative $slice keeps last N elements [OK]

Common Mistakes:

• Ignoring $slice and keeping all elements
• Using positive $slice logic incorrectly
• Removing new elements instead of old

4. You run this update:
db.collection.updateOne({ _id: 2 }, { $push: { logs: { $each: ["a", "b"], $slice: 1 } } })
But the array logs ends up with 1 element that is an old one instead of a newly pushed one. What is the likely mistake?

medium

A. Not specifying $position causes elements to append incorrectly

B. Missing $each causes syntax error

C. Using $slice with a negative number causes array to clear

D. Using positive $slice keeps first elements instead of newest ones

Solution

1. Step 1: Understand positive $slice behavior

   Positive $slice: 1 keeps only the first element of the array after push.

2. Step 2: Why old elements remain

   Positive $slice: 1 keeps the first (oldest) element of the resulting array since new elements are appended to the end.

3. Step 3: Common confusion

   Positive $slice keeps elements from the start, so if you want to keep the latest elements, use negative $slice.

4. Final Answer:

   Using positive $slice keeps first elements instead of newest ones -> Option D

5. Quick Check:

   Positive $slice keeps start elements [OK]

Hint: Use negative $slice to keep newest elements [OK]

Common Mistakes:

• Confusing positive and negative $slice behavior
• Omitting $each inside $push
• Expecting $slice to remove elements before push

5. You want to keep only the 5 most recent messages in a chat array after adding new messages ["msg4", "msg5"]. The current array is ["msg1", "msg2", "msg3", "msg4"]. Which update query correctly achieves this?

hard

A. db.collection.updateOne({ _id: 1 }, { $push: { chat: { $each: ["msg4", "msg5"], $slice: 5 } } })

B. db.collection.updateOne({ _id: 1 }, { $push: { chat: { $each: ["msg4", "msg5"], $slice: -5 } } })

C. db.collection.updateOne({ _id: 1 }, { $push: { chat: { $each: ["msg4", "msg5"], $slice: 2 } } })

D. db.collection.updateOne({ _id: 1 }, { $push: { chat: { $each: ["msg4", "msg5"], $slice: -2 } } })

Solution

1. Step 1: Understand the goal

   We want to add two new messages and keep only the 5 most recent messages in the array.

2. Step 2: Use $each and negative $slice

   $each adds multiple items. Negative $slice: -5 keeps the last 5 elements, which are the most recent.

3. Step 3: Check options

   db.collection.updateOne({ _id: 1 }, { $push: { chat: { $each: ["msg4", "msg5"], $slice: -5 } } }) uses $slice: -5 correctly. db.collection.updateOne({ _id: 1 }, { $push: { chat: { $each: ["msg4", "msg5"], $slice: 5 } } }) keeps first 5 elements (oldest), C keeps only 2 elements, D keeps last 2 elements, which is too few.

4. Final Answer:

   db.collection.updateOne({ _id: 1 }, { $push: { chat: { $each: ["msg4", "msg5"], $slice: -5 } } }) -> Option B

5. Quick Check:

   Negative $slice keeps newest 5 elements [OK]

Hint: Use negative $slice with $each to keep recent items [OK]

Common Mistakes:

• Using positive $slice which keeps oldest items
• Setting $slice too small and losing messages
• Forgetting $each when adding multiple items