$accumulator (accumulator operator)（累加器运算符）

Merge Two States with $merge使用$Merge合并两个状态

As part of its internal operations, the $accumulator operator may need to merge two separate, intermediate states. 作为其内部操作的一部分，$accumulator运算符可能需要合并两个单独的中间状态。The merge function specifies how the operator should merge two states.merge函数指定运算符应如何合并两个状态。

The merge function always merges two states at a time. In the event that more than two states must be merged, the resulting merge of two states is merged with a single state. This process repeats until all states are merged.merge函数总是一次合并两个状态。如果必须合并两个以上的状态，则两个状态的合并结果将与单个状态合并。重复此过程，直到合并所有状态。

For example, $accumulator may need to combine two states in the following scenarios:例如，在以下情况下，$accumulator可能需要组合两个状态：

• $accumulator is run on a sharded cluster. The operator needs to merge the results from each shard to obtain the final result.在分片集群上运行。运算符需要合并每个分片的结果以获得最终结果。
• A single $accumulator operation exceeds its specified memory limit. If you specify the allowDiskUse option, the operator stores the in-progress operation on disk and finishes the operation in memory. 单个$accumulator操作超过了其指定的内存限制。如果指定allowDiskUse选项，运算符会将正在进行的操作存储在磁盘上，并在内存中完成操作。Once the operation finishes, the results from disk and memory are merged together using the merge function.操作完成后，使用merge函数将磁盘和内存的结果合并在一起。

Document Processing Order文档处理顺序

The order that MongoDB processes documents for the init(), accumulate(), and merge() functions can vary, and might differ from the order that those documents are specified to the $accumulator function.MongoDB为init()、accumulate()和merge()函数处理文档的顺序可能会有所不同，并且可能与这些文档指定给$accumulator函数的顺序不同。

For example, consider a series of documents where the _id fields are the letters of the alphabet:例如，考虑一系列文档，其中_id字段是字母表中的字母：

{ _id: 'a' },
{ _id: 'b' },
{ _id: 'c' }
...
{ _id: 'z' }

Next, consider an aggregation pipeline that sorts the documents by the _id field and then uses an $accumulator function to concatenate the _id field values:接下来，考虑一个聚合管道，它按_id字段对文档进行排序，然后使用$accumulator函数连接_id字段值：

[
   {
      $sort: { _id: 1 }
   },
   {
      $group: {
         _id: null,
         alphabet: {
            $accumulator: {
               init: function() {
                  return ""
               },
               accumulate: function(state, letter) {
                  return(state + letter)
               },
               accumulateArgs: [ "$_id" ],
               merge: function(state1, state2) {
                  return(state1 + state2)
               },
               lang: "js"
            }
         }
      }
   }
]

MongoDB does not guarantee that the documents are processed in the sorted order, meaning the alphabet field does not necessarily get set to abc...z.MongoDB不保证文档按排序顺序处理，这意味着alphabet字段不一定设置为abc...z。

Due to this behavior, ensure that your $accumulator function does not need to process and return documents in a specific order.由于这种行为，请确保$accumulator函数不需要按特定顺序处理和返回文档。

Javascript EnabledJavascript已启用

To use $accumulator, you must have server-side scripting enabled.要使用$accumulator，您必须启用服务器端脚本。

If you do not use $accumulator (or $function, $where, or mapReduce), disable server-side scripting:如果不使用$accumulator（或$function、$where或mapReduce），请禁用服务器端脚本：

• For a mongod instance, see security.javascriptEnabled configuration option or --noscripting command-line option.对于mongod实例，请参阅security.javascriptEnabled配置选项或--noscripting命令行选项。

• For a mongos instance, see security.javascriptEnabled configuration option or the --noscripting command-line option.对于mongos实例，请参阅security.javascriptEnabled配置选项或--noscripting命令行选项。

  In earlier versions, MongoDB does not allow JavaScript execution on mongos instances.在早期版本中，MongoDB不允许在mongos实例上执行JavaScript。

See also ➤ Run MongoDB with Secure Configuration Options.另请参阅➤使用安全配置选项运行MongoDB。

Unsupported Array and String Functions不支持的数组和字符串函数

MongoDB 6.0 upgrades the internal JavaScript engine used for server-side JavaScript, $accumulator, $function, and $where expressions and from MozJS-60 to MozJS-91. MongoDB 6.0将用于服务器端JavaScript、$accumulator、$function和$where表达式的内部JavaScript引擎从MozJS-60升级到MozJS-91。Several deprecated, non-standard array and string functions that existed in MozJS-60 are removed in MozJS-91.MozJS-60中存在的几个已弃用的非标准数组和字符串函数在MozJS-91中被删除。

Use $accumulator to Implement the $avg Operator使用$accumulator实现$avg运算符

In mongosh, create a sample collection named books with the following documents:在mongosh中，使用以下文档创建一个名为books的示例集合：

db.books.insertMany([
  { _id: 8751, title: "The Banquet", author: "Dante", copies: 2 },
  { _id: 8752, title: "Divine Comedy", author: "Dante", copies: 1 },
  { _id: 8645, title: "Eclogues", author: "Dante", copies: 2 },
  { _id: 7000, title: "The Odyssey", author: "Homer", copies: 10 },
  { _id: 7020, title: "Iliad", author: "Homer", copies: 10 }
])

The following operation groups the documents by author, and uses $accumulator to compute the average number of copies across books for each author:以下操作按author对文档进行分组，并使用$accumulator计算每个作者跨书的平均份数：

db.books.aggregate([
{
  $group :
  {
    _id : "$author",
    avgCopies:
    {
      $accumulator:
      {
        init: function() {                        // Set the initial state设置初始状态
          return { count: 0, sum: 0 }
        },

        accumulate: function(state, numCopies) {  // Define how to update the state定义如何更新状态
          return {
            count: state.count + 1,
            sum: state.sum + numCopies
          }
        },

        accumulateArgs: ["$copies"],              // Argument required by the accumulate function累加函数所需的参数

        merge: function(state1, state2) {         // When the operator performs a merge,当运算符执行合并操作时，
          return {                                // add the fields from the two states添加这两个州的字段
            count: state1.count + state2.count,
            sum: state1.sum + state2.sum
          }
        },

        finalize: function(state) {               // After collecting the results from all documents,在从所有文档中集合结果之后，
          return (state.sum / state.count)        // calculate the average计算平均值
        },
        lang: "js"
      }
    }
  }
}
])

{ _id: "Dante", avgCopies: 1.6666666666666667 }
{ _id: "Homer", avgCopies: 10 }

db.books.aggregate([
{
  $group : {
    _id : "$author",
    avgCopies: { $avg: "$copies" }
  }
}
])

Use initArgs to Vary the Initial State by Group使用initArgs按组改变初始状态

You can use the initArgs option in to vary the initial state of $accumulator. This can be useful if you want to, for example:您可以使用中的initArgs选项来改变$accumulator的初始状态。如果你愿意，这可能很有用，例如：

• Use the value of a field which is not in your state to affect your state, or使用不在您所在州的字段值来影响州，或
• Set the initial state to a different value based on the group being processed.根据正在处理的组将初始状态设置为不同的值。

In mongosh, create a sample collection named restaurants with the following documents:在mongosh中，使用以下文档创建一个名为restaurants的样本集合：

db.restaurants.insertMany( [
  { _id: 1, name: "Food Fury", city: "Bettles", cuisine: "American" },
  { _id: 2, name: "Meal Macro", city: "Bettles", cuisine: "Chinese" },
  { _id: 3, name: "Big Crisp", city: "Bettles", cuisine: "Latin" },
  { _id: 4, name: "The Wrap", city: "Onida", cuisine: "American" },
  { _id: 5, name: "Spice Attack", city: "Onida", cuisine: "Latin" },
  { _id: 6, name: "Soup City", city: "Onida", cuisine: "Chinese" },
  { _id: 7, name: "Crave", city: "Pyote", cuisine: "American" },
  { _id: 8, name: "The Gala", city: "Pyote", cuisine: "Chinese" }
] )

Suppose an application allows users to query this data to find restaurants. It may be useful to show more results for the city where the user lives. For this example, we assume that the user's city is called in a variable called userProfileCity.假设一个应用程序允许用户查询这些数据以查找餐馆。为用户居住的城市显示更多结果可能很有用。对于这个例子，我们假设在一个名为userProfileCity的变量中调用用户的城市。

The following aggregation pipeline groups the documents by city. 以下聚合管道按city对文档进行分组。The operation uses the $accumulator to display a different number of results from each city depending on whether the restaurant's city matches the city in the user's profile:该操作使用$accumulator显示来自每个城市的不同数量的结果，具体取决于餐厅的城市是否与用户个人资料中的城市匹配：

db.restaurants.aggregate([
{
  $group :
  {
    _id : { city: "$city" },
    restaurants:
    {
      $accumulator:
      {
        init: function(city, userProfileCity) {        // Set the initial state设置初始状态
          return {
            max: city === userProfileCity ? 3 : 1,     // If the group matches the user's city, return 3 restaurants如果该组与用户所在城市匹配，则返回3家餐厅
            restaurants: []                            // else, return 1 restaurant否则，返回1家餐厅
          }
        },

        initArgs: ["$city", <userProfileCity>],        // Argument to pass to the init function传递给init函数的参数

        accumulate: function(state, restaurantName) {  // Define how to update the state定义如何更新状态
          if (state.restaurants.length < state.max) {
            state.restaurants.push(restaurantName);
          }
          return state;
        },

        accumulateArgs: ["$name"],                     // Argument required by the accumulate function累加函数所需的参数

        merge: function(state1, state2) {
          return {
            max: state1.max,
            restaurants: state1.restaurants.concat(state2.restaurants).slice(0, state1.max)
          }
        },

        finalize: function(state) {                   // Adjust the state to only return field we need将状态调整为仅返回我们需要的字段
          return state.restaurants
        }

        lang: "js"
      }
    }
  }
}
])

{ _id: { city: "Bettles" }, restaurants: { restaurants: [ "Food Fury", "Meal Macro", "Big Crisp" ] } }
{ _id: { city: "Onida" }, restaurants: { restaurants: [ "The Wrap" ] } }
{ _id: { city: "Pyote" }, restaurants: { restaurants: [ "Crave" ] } }

{ _id: { city: "Bettles" }, restaurants: { restaurants: [ "Food Fury" ] } }
{ _id: { city: "Onida" }, restaurants: { restaurants: [ "The Wrap", "Spice Attack", "Soup City" ] } }
{ _id: { city: "Pyote" }, restaurants: { restaurants: [ "Crave" ] } }

{ _id: { city: "Bettles" }, restaurants: { restaurants: [ "Food Fury" ] } }
{ _id: { city: "Onida" }, restaurants: { restaurants: [ "The Wrap" ] } }
{ _id: { city: "Pyote" }, restaurants: { restaurants: [ "Crave", "The Gala" ] } }

{ _id: { city: "Bettles" }, restaurants: { restaurants: [ "Food Fury" ] } }
{ _id: { city: "Onida" }, restaurants: { restaurants: [ "The Wrap" ] } }
{ _id: { city: "Pyote" }, restaurants: { restaurants: [ "Crave" ] } }