Array expressions ($size, $arrayElemAt, $filter) in MongoDB - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the $size array expression do in MongoDB?

The $size expression returns the number of elements in an array.

It helps you count how many items are inside an array field.

beginner

How does $arrayElemAt work in MongoDB?

$arrayElemAt returns the element at a specific position in an array.

Positions start at 0, so $arrayElemAt: [array, 0] gives the first item.

intermediate

Explain the purpose of $filter in MongoDB array expressions.

$filter lets you select only the elements in an array that match a condition.

It creates a new array with just the items you want.

intermediate

What happens if you use $size on a field that is not an array?

If the field is not an array (including null or missing), $size throws an error.

advanced

How can $filter be combined with $size to count filtered elements?

You can use $filter to create a smaller array with only matching elements, then use $size to count how many matched.

What does $size return when used on an array?

A The last element of the array

B The number of elements in the array

C A filtered version of the array

D The first element of the array

$size counts how many elements are inside an array.

Which expression would you use to get the third element of an array?

A <code>$filter</code>

B <code>$size</code>

C <code>$arrayElemAt</code> with index 2

D <code>$arrayElemAt</code> with index 3

Arrays start at index 0, so the third element is at index 2.

What does $filter do in MongoDB?

A Selects elements matching a condition

B Returns an element at a position

C Counts elements in an array

D Sorts the array elements

$filter creates a new array with only elements that meet a condition.

What will happen if $size is used on a non-array field?

A Returns 0

B Returns null

C Returns 1

D Throws an error

$size expects an array and throws an error if given something else.

How can you count only the elements in an array that meet a condition?

A Use <code>$filter</code> then <code>$size</code>

B Use <code>$arrayElemAt</code> with <code>$size</code>

C Use <code>$size</code> alone

D Use <code>$filter</code> alone

First filter the array, then count the filtered elements with $size.

Describe how to use $filter to select elements from an array based on a condition.

Think about how you pick only certain items from a list.

Explain how $arrayElemAt and $size can be used together in a query.

One picks an item, the other counts items.

Practice

1. What does the MongoDB expression $size do when used on an array field?

easy

A. Counts how many elements are in the array

B. Returns the first element of the array

C. Filters elements based on a condition

D. Sorts the array elements

Solution

1. Step 1: Understand the purpose of $size

   The $size operator counts the number of elements inside an array.

2. Step 2: Compare with other operators

   $arrayElemAt picks an element by position, $filter selects elements by condition, and sorting is unrelated.

3. Final Answer:

   Counts how many elements are in the array -> Option A

4. Quick Check:

   $size = count elements [OK]

Hint: Remember $size counts array length, not elements themselves [OK]

Common Mistakes:

• Confusing $size with $arrayElemAt
• Thinking $size filters elements
• Assuming $size sorts arrays

2. Which of the following is the correct syntax to get the third element of an array field named items using MongoDB aggregation?

easy

A. { $arrayElemAt: ["items", 3] }

B. { $size: ["$items", 2] }

C. { $arrayElemAt: ["$items", 2] }

D. { $filter: { input: "$items", as: "item", cond: { $eq: ["$$item", 2] } } }

Solution

1. Step 1: Recall zero-based indexing in $arrayElemAt

   The third element is at index 2 because counting starts at 0.

2. Step 2: Check syntax correctness

   The correct syntax uses $arrayElemAt with the array field prefixed by $ and the zero-based index.

3. Final Answer:

   { $arrayElemAt: ["$items", 2] } -> Option C

4. Quick Check:

   Third element index = 2 [OK]

Hint: Remember arrays start at 0, so third element is index 2 [OK]

Common Mistakes:

• Using 1-based index instead of 0-based
• Missing $ before field name
• Confusing $size with $arrayElemAt

3. Given the document { scores: [10, 20, 30, 40] }, what will the aggregation expression { $size: "$scores" } return?

medium

A. 4

B. 30

C. [10, 20, 30, 40]

D. Error

Solution

1. Step 1: Understand what $size does

   $size counts the number of elements in the array.

2. Step 2: Count elements in the array

   The array [10, 20, 30, 40] has 4 elements.

3. Final Answer:

   4 -> Option A

4. Quick Check:

   Array length = 4 [OK]

Hint: Count elements inside brackets for $size result [OK]

Common Mistakes:

• Returning the third element instead of count
• Returning the whole array instead of count
• Assuming syntax error

4. Identify the error in this MongoDB aggregation expression: { $arrayElemAt: ["$values", "1"] }

medium

A. Field name missing $ prefix

B. Index must be a number, not a string

C. Array must be inside an object

D. No error, expression is correct

Solution

1. Step 1: Check the type of index in $arrayElemAt

   The index must be a number, but here it is a string "1".

2. Step 2: Confirm correct field referencing

   The field name "$values" is correctly prefixed with $.

3. Final Answer:

   Index must be a number, not a string -> Option B

4. Quick Check:

   Index type = number, not string [OK]

Hint: Use number type for index in $arrayElemAt [OK]

Common Mistakes:

• Using string instead of number for index
• Omitting $ before field name
• Thinking array must be wrapped differently

5. You have documents with a field tags as an array of strings. How would you write a MongoDB aggregation expression to get the count of tags that start with the letter 'a'?

hard

A. { $size: "$tags" }

B. { $arrayElemAt: ["$tags", 0] }

C. { $filter: { input: "$tags", as: "tag", cond: { $eq: ["$$tag", "a"] } } }

D. { $size: { $filter: { input: "$tags", as: "tag", cond: { $regexMatch: { input: "$$tag", regex: /^a/ } } } } }

Solution

1. Step 1: Use $filter to select tags starting with 'a'

   The $filter operator creates a new array with tags matching the regex /^a/.

2. Step 2: Use $size to count filtered tags

   $size counts how many tags matched the condition.

3. Final Answer:

   { $size: { $filter: { input: "$tags", as: "tag", cond: { $regexMatch: { input: "$$tag", regex: /^a/ } } } } } -> Option D

4. Quick Check:

   Filter then count = correct approach [OK]

Hint: Filter first, then count with $size for conditional counts [OK]

Common Mistakes:

• Using $arrayElemAt instead of $filter
• Filtering with exact match instead of regex
• Counting whole array without filtering