MongoDB $reduce Operator

What Is $reduce?

$reduce is a MongoDB aggregation expression that folds an array into one value. It walks each element, updates an accumulator, and returns the final result—like JavaScript’s Array.reduce().

$reduce = fold array → one value

{ $reduce: {
    input: <array>,
    initialValue: <start>,
    in: <expression>
  }
}

inside in:
  $$value → accumulator (so far)
  $$this  → current element

empty array → initialValue
null input  → null

How to Use $reduce in MongoDB

Provide the array, a starting accumulator, and the update expression.

1. Choose an expression stage ($addFields or $project).
2. Set input to the array field (for example "$scores").
3. Set initialValue (for a sum, start at 0).
4. In in, combine $$value and $$this (for example with $add).

Pseudocode

arr = evaluate(input)
if arr is null or missing:
    result = null
else:
    acc = evaluate(initialValue)
    for each element in arr:
        $$this  = element
        $$value = acc
        acc = evaluate(in)
    result = acc
emit { ..., field: result }

Cheat Sheet

Keep these facts handy while folding arrays in pipelines.

Live Preview

Watch $reduce fold [10, 20, 30] into a sum, a max, or a joined string.

input = [10, 20, 30]
initialValue = 0

step 1: $$value=0  $$this=10 → 10
step 2: $$value=10 $$this=20 → 30
step 3: $$value=30 $$this=30 → 60

result → 60

Worked Walkthrough — Sum Scores

Asha has quiz scores 10, 20, 30. We start the accumulator at 0 and add each score with $reduce.

scores = [10, 20, 30]
initialValue = 0

in: { $add: ["$$value", "$$this"] }

  start     $$value = 0
  + 10   →  $$value = 10
  + 20   →  $$value = 30
  + 30   →  $$value = 60

final → 60

MongoDB Examples

We use one student with three scores. First insert the sample, then sum with $reduce, then join tags into one string. Run these in mongosh after inserting the sample data once.

db.students.insertOne({
  _id: 1,
  name: "Asha",
  scores: [10, 20, 30],
  tags: ["math", "quiz"]
});

db.students.find()

{
  _id: 1,
  name: "Asha",
  scores: [10, 20, 30],
  tags: ["math", "quiz"]
}

scores:  10 → 20 → 30
fold +:   0 → 10 → 30 → 60

tags:    "math" → "quiz"
fold -:  "" → "math" → "math-quiz"

db.students.aggregate([
  {
    $addFields: {
      total: {
        $reduce: {
          input: "$scores",
          initialValue: 0,
          in: { $add: ["$$value", "$$this"] }
        }
      }
    }
  }
]);

{
  _id: 1,
  name: "Asha",
  scores: [10, 20, 30],
  tags: ["math", "quiz"],
  total: 60
}

db.students.aggregate([
  {
    $addFields: {
      label: {
        $reduce: {
          input: "$tags",
          initialValue: "",
          in: {
            $cond: [
              { $eq: ["$$value", ""] },
              "$$this",
              { $concat: ["$$value", "-", "$$this"] }
            ]
          }
        }
      }
    }
  }
]);

{
  _id: 1,
  name: "Asha",
  scores: [10, 20, 30],
  tags: ["math", "quiz"],
  label: "math-quiz"
}

Performance Notes

$reduce visits every element once. That is fine for short arrays; avoid folding very large arrays on hot paths when a simpler operator will do.

Key Takeaways