MongoDB $reverseArray Operator

What You’ll Learn

The $reverseArray operator flips the order of elements in an array inside MongoDB aggregation pipelines. Use it to show newest-first timelines, reorder tags, or prepare data for downstream stages like $slice.

Definition and Usage

In MongoDB’s aggregation framework, the $reverseArray operator accepts an array and returns a new array with elements in reverse order. For example, reversing ["a", "b", "c"] gives ["c", "b", "a"].

This is useful when data is stored oldest-first but you want to display newest-first, or when you need the last items in a sequence without changing how they were saved. The original document field is not modified unless you explicitly write the result back.

📝 Syntax

The $reverseArray operator takes a single array expression:

{ $reverseArray: <array expression> }

Examples of Valid Input

{ $reverseArray: "$tags" }
{ $reverseArray: [1, 2, 3] }
{ $reverseArray: { $slice: ["$history", 5] } }

Syntax Rules

• Argument — any expression that evaluates to an array (field path or literal).
• Output — a new array with elements in reverse index order.
• Empty array — [] reverses to [].
• Null / missing — returns null when input is null or missing.
• Nested arrays — reverses top-level elements only; inner arrays stay as-is.
• Use inside $project, $addFields, or $set (MongoDB 3.4+).

Examples Gallery

Reverse tag lists, flip activity timelines, combine with $slice, and handle empty arrays with $reverseArray.

[
  {
    "_id": 1,
    "title": "MongoDB Basics",
    "tags": ["database", "nosql", "tutorial"]
  },
  {
    "_id": 2,
    "title": "Empty Tags",
    "tags": []
  },
  {
    "_id": 3,
    "title": "Activity Log",
    "events": ["created", "edited", "published"]
  }
]

db.articles.aggregate([
  {
    $project: {
      title: 1,
      tags: 1,
      tagsReversed: {
        $reverseArray: "$tags"
      }
    }
  }
])

// Article 1:
// tags:         ["database", "nosql", "tutorial"]
// tagsReversed: ["tutorial", "nosql", "database"]
// Article 2:
// tagsReversed: []

db.articles.aggregate([
  {
    $match: { events: { $exists: true } }
  },
  {
    $project: {
      title: 1,
      recentFirst: {
        $reverseArray: "$events"
      }
    }
  }
])

// events: ["created", "edited", "published"]
// recentFirst: ["published", "edited", "created"]

db.articles.aggregate([
  {
    $project: {
      title: 1,
      latestTwo: {
        $slice: [
          { $reverseArray: "$events" },
          2
        ]
      }
    }
  }
])

// latestTwo: ["published", "edited"]

db.articles.aggregate([
  {
    $project: {
      title: 1,
      tags: {
        $reverseArray: "$tags"
      }
    }
  }
])

// tags in output: ["tutorial", "nosql", "database"]

db.games.aggregate([
  {
    $project: {
      game: 1,
      topScores: "$scores",
      bottomUp: {
        $reverseArray: "$scores"
      }
    }
  }
])

// scores: [980, 850, 720]
// bottomUp: [720, 850, 980]

🚀 Use Cases

• UI display — show newest-first timelines, comments, or notifications.
• Stack simulation — treat a FIFO list as LIFO for processing logic.
• Last-N extraction — combine with $slice after reversing.
• Data transformation — reorder arrays in ETL without application-side code.

💡 Best Practices