Why $slice modifier with $push in MongoDB? - Purpose & Use Cases

The Big Idea

What if you could add items to a list and keep it perfectly sized with just one command?

The Scenario

Imagine you have a list of recent messages in a chat app stored as an array. You want to add new messages but keep only the latest 10 to save space.

The Problem

Manually checking the array length and removing old messages every time you add a new one is slow and error-prone. It requires extra code and can easily break if you forget to trim the list.

The Solution

The $slice modifier with $push lets you add new items and automatically keep the array size limited in one simple step. This keeps your data clean and your code simple.

Before vs After

✗ Before

messages.push(newMessage);
if (messages.length > 10) {
  messages.shift();
}

✓ After

db.collection.updateOne(
  { _id: chatId },
  { $push: { messages: { $each: [newMessage], $slice: -10 } } }
)

What It Enables

You can efficiently maintain fixed-size lists in your database without extra code or errors.

Real Life Example

In a social media app, keep only the latest 10 notifications per user by pushing new ones and slicing the array automatically.

Key Takeaways

Manually managing array size is complicated and error-prone.

$slice with $push trims arrays automatically when adding items.

This keeps your data tidy and your code simple.

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