$slice modifier with $push in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What is the output after using $push with $slice?

Consider a MongoDB document with an array field scores initially as [10, 20, 30]. We run this update:

{ $push: { scores: { $each: [40, 50], $slice: -3 } }}

What will be the scores array after this update?

A [30, 40, 50]

B [10, 20, 30, 40, 50]

C [20, 30, 40, 50]

D [40, 50]

💡 Hint

Remember that $slice with a negative number keeps the last N elements.

The $push with $each adds 40 and 50 to the array, making it [10, 20, 30, 40, 50]. Then $slice: -3 keeps only the last 3 elements, which are [30, 40, 50].

📝 Syntax

intermediate

Which update query is syntactically correct for $push with $slice?

Choose the syntactically valid MongoDB update query that uses $push with $slice to limit array size.

A { $push: { items: { $each: [1,2,3], $slice: -2 } } }

B { $push: { items: { $slice: -2, $each: [1,2,3] } } }

C { $push: { items: { $each: [1,2,3], $slice: 2 } } }

D { $push: { items: { $each: [1,2,3], $limit: 2 } } }

💡 Hint

The order of $each and $slice matters, and $limit is not a valid modifier.

Option A is correct because $each and $slice are used properly, and $slice can be negative to keep last N elements. Option A uses positive slice which keeps first N elements but is valid syntax too, but the question asks for correct syntax with negative slice. Option A has wrong order, and Option A uses invalid $limit.

❓ optimization

advanced

How to efficiently keep only the last 5 elements in an array using $push?

You want to add multiple elements to an array field logs and keep only the last 5 elements to save space. Which update query is the most efficient?

A { $push: { logs: { $each: newEntries, $sort: -1, $slice: 5 } } }

B { $push: { logs: { $each: newEntries } }, $slice: -5 }

C { $push: { logs: newEntries }, $slice: -5 }

D { $push: { logs: { $each: newEntries, $slice: -5 } } }

💡 Hint

Remember that $slice must be inside the $push modifier with $each.

Option D correctly uses $each to add multiple elements and $slice: -5 to keep the last 5 elements. Option D and C place $slice outside $push, which is invalid. Option D uses $sort which is not a valid modifier in this context.

🔧 Debug

advanced

Why does this $push update with $slice not work as expected?

Given this update query:

{ $push: { data: { $each: [5,6], $slice: 2 } }}

The array data ends up with only the first 2 elements instead of the last 2. Why?

A Because $slice must be negative to work with $each.

B Because $each must be after $slice in the query.

C Because $slice with positive number keeps the first N elements, not the last.

D Because $slice only works with $pop, not $push.

💡 Hint

Think about what positive and negative values for $slice mean.

A positive $slice keeps the first N elements of the array after pushing. To keep the last N elements, $slice must be negative. So the array keeps the first 2 elements, not the last 2.

🧠 Conceptual

expert

What happens if $slice is zero in a $push update?

In MongoDB, if you run this update:

{ $push: { arr: { $each: [7,8], $slice: 0 } }}

What will be the resulting arr array?

A The array will contain only [7,8].

B The array will be empty after the update.

C The array will remain unchanged.

D The update will cause a syntax error.

💡 Hint

Think about what $slice: 0 means for array length.

$slice: 0 means keep zero elements, so after pushing the new elements, the array is trimmed to zero length, resulting in an empty array.

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