0Pricing
MongoDB Academy · 课时

$first、$last 以及 $top/$bottom 累加器

您将选取每组中的第一个或最后一个文档，并使用较新的 $top 和 $bottom 累加器按排序键进行选取。

$first、$last 以及 $top/$bottom 累加器 是 CoddyKit 上的免费 MongoDB Academy 课时。 这是第 3 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 MongoDB Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 MongoDB Academy 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Picking One Document Per Group

Sometimes aggregation needs to select a single representative document from each group rather than computing a numeric aggregate. MongoDB provides several accumulators for this: $first, $last, and the newer $top and $bottom accumulators. Each has different semantics for determining which document is selected, and choosing the right one affects both correctness and performance.

$first: Taking the Earliest Document Value

$first returns the value from the first document encountered in the group. Since MongoDB does not guarantee document processing order within a $group unless you sort first, $first is meaningful only when you place a $sort stage immediately before the $group. This two-stage pattern—sort then group—is the standard way to reliably pick the earliest or highest-priority item per group.

db.orders.aggregate([
  // Sort by date ascending so $first gets the oldest order
  { $sort: { createdAt: 1 } },
  {
    $group: {
      _id: '$customerId',
      firstOrderDate: { $first: '$createdAt' },
      firstOrderAmount: { $first: '$amount' },
      firstOrderId: { $first: '$_id' }
    }
  }
])

$last: Taking the Latest Document Value

$last returns the value from the last document encountered in the group. Again, this is meaningful only when combined with a preceding $sort. Sort ascending and use $last to get the most recent value per group. Sort descending and use $first to achieve the same result. The most common use case is finding each user's or customer's most recent activity.

db.loginEvents.aggregate([
  // Sort ascending: $last will be the most recent event
  { $sort: { timestamp: 1 } },
  {
    $group: {
      _id: '$userId',
      lastLoginTime: { $last: '$timestamp' },
      lastLoginIp: { $last: '$ipAddress' },
      totalLogins: { $sum: 1 }
    }
  }
])

Performance Cost of Sort Before Group

The pattern of $sort before $group has an important performance implication: it prevents MongoDB from pushing the $group in front of the $sort during pipeline optimization. If the collection is large and you have an index on the sort field, MongoDB can use it for the sort phase but still must sort all documents before grouping. For very large collections, this can be expensive. The $top and $bottom accumulators were introduced partly to address this limitation.

// Potentially expensive on large collections:
// MongoDB must sort ALL documents before grouping
db.events.aggregate([
  { $sort: { timestamp: -1 } }, // sorts entire collection
  {
    $group: {
      _id: '$userId',
      latestEvent: { $first: '$eventType' }
    }
  }
])

$top: Pick by Sort Key Within Group

Introduced in MongoDB 5.2, $top lets you pick the top document within each group according to a sort specification—without a separate $sort stage. You specify a sortBy expression and an output expression directly inside the accumulator. MongoDB evaluates the sort per group, which can be more efficient than sorting the entire collection first.

db.orders.aggregate([
  {
    $group: {
      _id: '$customerId',
      mostRecentOrder: {
        $top: {
          sortBy: { createdAt: -1 }, // highest date first
          output: {
            orderId: '$_id',
            amount: '$amount',
            date: '$createdAt'
          }
        }
      }
    }
  }
])

$bottom: Pick the Last by Sort Key

$bottom is the complement to $top—it returns the document that would appear last after sorting by the given key within each group. Use $bottom with sortBy: { timestamp: 1 } to get the earliest event per group, or use $top with the opposite sort direction—both approaches are equivalent. Choose whichever expresses your intent more clearly.

db.gameScores.aggregate([
  {
    $group: {
      _id: '$playerId',
      highestScore: {
        $top: {
          sortBy: { score: -1 },
          output: { score: '$score', level: '$level', date: '$date' }
        }
      },
      lowestScore: {
        $bottom: {
          sortBy: { score: -1 },
          output: { score: '$score', level: '$level', date: '$date' }
        }
      }
    }
  }
])

$topN and $bottomN: Picking Multiple Items

MongoDB also provides $topN and $bottomN accumulators that return an array of the top or bottom N documents per group according to a sort key. This is useful for leaderboard-style queries where you want the top 3 scores per level or the 5 most recent orders per customer, all computed in a single $group stage.

db.scores.aggregate([
  {
    $group: {
      _id: '$gameId',
      top3Players: {
        $topN: {
          n: 3,
          sortBy: { score: -1 },
          output: { playerId: '$playerId', score: '$score' }
        }
      }
    }
  }
])

Choosing Between $first/$last and $top/$bottom

Use $first/$last when you are already sorting the pipeline for other reasons and want a simple, familiar API. Use $top/$bottom when you only need the selection behavior and want to avoid the cost of a full collection sort before $group. In practice, $top/$bottom with appropriate indexes can be significantly faster for large collections because MongoDB may be able to optimize the per-group selection more efficiently.

// Prefer $top when no prior $sort is needed for other stages:
db.orders.aggregate([
  {
    $group: {
      _id: '$region',
      latestOrder: {
        $top: { sortBy: { date: -1 }, output: { amount: '$amount', date: '$date' } }
      }
    }
  }
]);

// Use $first when you are already sorting for other accumulators:
db.orders.aggregate([
  { $sort: { date: -1 } },
  {
    $group: {
      _id: '$region',
      latestDate: { $first: '$date' },
      latestAmount: { $first: '$amount' },
      allAmounts: { $push: '$amount' } // also needs sorted input
    }
  }
])

Practical Use Case: Latest Price Per Product

A classic real-world use case is maintaining a price history collection and querying the latest effective price for each product. Using $top with sort by date descending makes this query concise and efficient. The result is one document per product containing its current price without needing a separate 'current price' collection.

db.priceHistory.aggregate([
  {
    $group: {
      _id: '$productId',
      currentPrice: {
        $top: {
          sortBy: { effectiveDate: -1 },
          output: {
            price: '$price',
            currency: '$currency',
            effectiveDate: '$effectiveDate'
          }
        }
      }
    }
  }
])

Combining Accumulators in One $group

You can freely combine $first, $last, $top, $bottom, $sum, $avg, and $push in a single $group stage. Each accumulator operates independently on the documents in the group. This lets you compute summary statistics alongside picking representative documents in one efficient aggregation stage, avoiding multiple passes over the data.

db.transactions.aggregate([
  { $sort: { timestamp: 1 } },
  {
    $group: {
      _id: '$accountId',
      firstTransaction: { $first: '$timestamp' },
      lastTransaction: { $last: '$timestamp' },
      transactionCount: { $sum: 1 },
      totalVolume: { $sum: '$amount' },
      avgTransaction: { $avg: '$amount' },
      largestTransaction: { $max: '$amount' }
    }
  }
])

Version Compatibility Notes

$first and $last have been available since early MongoDB versions. The $top and $bottom accumulators were introduced in MongoDB 5.2, and $topN/$bottomN also became available around that time. If you are using an older MongoDB version (pre-5.2), fall back to the $sort then $first/$last pattern. Check your Atlas cluster version or self-hosted version before using newer operators.

Quick Check

Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.

Lesson Recap

In this lesson you learned: $first/$last pick values from the first/last document in a group (requires prior $sort), $top/$bottom (MongoDB 5.2+) pick by sort key within the group without a separate $sort stage, and $topN/$bottomN return arrays of the top or bottom N items per group. Next up we explore window functions with $setWindowFields for running totals and moving averages.

常见问题解答

「$first、$last 以及 $top/$bottom 累加器」课时是免费的吗？

是的 — 「$first、$last 以及 $top/$bottom 累加器」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 MongoDB Academy 课程的其余内容，请升级到 CoddyKit PRO。 MongoDB Academy 课程共包含 4 节课。

「$first、$last 以及 $top/$bottom 累加器」这节课中我会学到什么？

您将选取每组中的第一个或最后一个文档，并使用较新的 $top 和 $bottom 累加器按排序键进行选取。 你通过在浏览器中直接运行的动手代码来练习 MongoDB Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 MongoDB Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 MongoDB Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 4 节。

「$first、$last 以及 $top/$bottom 累加器」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 MongoDB Academy 课中编写并运行代码吗？

能。每节 MongoDB Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. $sum、$avg、$min、$max：数值聚合
  2. $push 和 $addToSet：在分组中构建数组
  3. $first、$last 以及 $top/$bottom 累加器
  4. 使用 $setWindowFields 进行窗口函数计算
← 返回 MongoDB Academy