聚合操作符

算术操作符

abs

聚合操作符。返回一个数字的绝对值。

API 说明

语法如下：

db.command.aggregate.abs(<number>)

abs 传入的值除了数字常量外，也可以是任何最终解析成一个数字的表达式。

如果表达式解析为 null 或者指向一个不存在的字段，则 abs 的结果是 null。如果值解析为 NaN，则结果是 NaN。

示例代码

假设集合 ratings 有如下记录：

{ _id: 1, start: 5, end: 8 }
{ _id: 2, start: 4, end: 4 }
{ _id: 3, start: 9, end: 7 }
{ _id: 4, start: 6, end: 7 }

···可以用如下方式求得各个记录的 start 和 end 之间的绝对差异大小：

const $ = db.command.aggregate
db.collection('ratings').aggregate()
  .project({
    delta: $.abs($.subtract(['$start', '$end']))
  })
  .end()

返回结果如下：

{ "_id" : 1, "delta" : 3 }
{ "_id" : 2, "delta" : 0 }
{ "_id" : 3, "delta" : 2 }
{ "_id" : 4, "delta" : 1 }

add

聚合操作符。将数字相加或将数字加在日期上。如果数组中的其中一个值是日期，那么其他值将被视为毫秒数加在该日期上。

API 说明

语法如下：

db.command.aggregate.add([<表达式1>, <表达式2>, ...])

表达式可以是形如 $ + 指定字段，也可以是普通字符串。只要能够被解析成字符串即可。

示例代码

假设集合 staff 有如下记录：

{ _id: 1, department: "x", sales: 5, engineer: 10, lastUpdate: ISODate("2019-05-01T00:00:00Z") }
{ _id: 2, department: "y", sales: 10, engineer: 20, lastUpdate: ISODate("2019-05-01T02:00:00Z") }
{ _id: 3, department: "z", sales: 20, engineer: 5, lastUpdate: ISODate("2019-05-02T03:00:00Z") }

数字求和

可以用如下方式求得各个记录人数总数：

const $ = db.command.aggregate
db.collection('staff').aggregate()
  .project({
    department: 1,
    total: $.add(['$sales', '$engineer'])
  })
  .end()

返回结果如下：

{ _id: 1, department: "x", total: 15 }
{ _id: 2, department: "y", total: 30 }
{ _id: 3, department: "z", total: 25 }

增加日期值

如下操作可以获取各个记录的 lastUpdate 加一个小时之后的值：

const $ = db.command.aggregate
db.collection('staff').aggregate()
  .project({
    department: 1,
    lastUpdate: $.add(['$lastUpdate', 60*60*1000])
  })
  .end()

返回结果如下：

{ _id: 1, department: "x", lastUpdate: ISODate("2019-05-01T01:00:00Z") }
{ _id: 2, department: "y", lastUpdate: ISODate("2019-05-01T03:00:00Z") }
{ _id: 3, department: "z", lastUpdate: ISODate("2019-05-02T04:00:00Z") }

ceil

聚合操作符。向上取整，返回大于或等于给定数字的最小整数。

API 说明

语法如下：

db.command.aggregate.ceil(<number>)

<number> 可以是任意解析为数字的表达式。如果表达式解析为 null 或指向一个不存在的字段，则返回 null，如果解析为 NaN，则返回 NaN。

示例代码

假设集合 sales 有如下记录：

{ _id: 1, sales: 5.2 }
{ _id: 2, sales: 1.32 }
{ _id: 3, sales: -3.2 }

可以用如下方式取各个数字的向上取整值：

const $ = db.command.aggregate
db.collection('sales').aggregate()
  .project({
    sales: $.ceil('$sales')
  })
  .end()

返回结果如下：

{ _id: 1, sales: 6 }
{ _id: 2, sales: 2 }
{ _id: 3, sales: -3 }

divide

聚合操作符。传入被除数和除数，求商。

API 说明

语法如下：

db.command.aggregate.divide([<被除数表达式>, <除数表达式>])

表达式可以是任意解析为数字的表达式。

示例代码

假设集合 railroads 有如下记录：

{ _id: 1, meters: 5300 }
{ _id: 2, meters: 64000 }
{ _id: 3, meters: 130 }

可以用如下方式取各个数字转换为千米之后的值：

const $ = db.command.aggregate
db.collection('railroads').aggregate()
  .project({
    km: $.divide(['$meters', 1000])
  })
  .end()

返回结果如下：

{ _id: 1, km: 5.3 }
{ _id: 2, km: 64 }
{ _id: 3, km: 0.13 }

exp

聚合操作符。取 e（自然对数的底数，欧拉数） 的 n 次方。

API 说明

语法如下：

db.command.aggregate.exp(<exponent>)

<exponent> 可以是任意解析为数字的表达式。如果表达式解析为 null 或指向一个不存在的字段，则返回 null，如果解析为 NaN，则返回 NaN。

示例代码

假设集合 math 有如下记录：

{ _id: 1, exp: 0 }
{ _id: 2, exp: 1 }
{ _id: 3, exp: 2 }

const $ = db.command.aggregate
db.collection('math').aggregate()
  .project({
    result: $.exp('$exp')
  })
  .end()

返回结果如下：

{ _id: 1, result: 1 }
{ _id: 2, result: 2.71828182845905 }
{ _id: 3, result: 7.38905609893065 }

floor

聚合操作符。向下取整，返回大于或等于给定数字的最小整数。

API 说明

语法如下：

db.command.aggregate.floor(<number>)

<number> 可以是任意解析为数字的表达式。如果表达式解析为 null 或指向一个不存在的字段，则返回 null，如果解析为 NaN，则返回 NaN。

示例代码

假设集合 sales 有如下记录：

{ _id: 1, sales: 5.2 }
{ _id: 2, sales: 1.32 }
{ _id: 3, sales: -3.2 }

可以用如下方式取各个数字的向下取整值：

const $ = db.command.aggregate
db.collection('sales').aggregate()
  .project({
    sales: $.floor('$sales')
  })
  .end()

返回结果如下：

{ _id: 1, sales: 5 }
{ _id: 2, sales: 1 }
{ _id: 3, sales: -6 }

ln

聚合操作符。计算给定数字在自然对数值。

API 说明

语法如下：

db.command.aggregate.ln(<number>)

<number> 可以是任意解析为非负数字的表达式。

ln 等价于 log([<number>, Math.E])，其中 Math.E 是 JavaScript 获取 e 的值的方法。

示例代码

db.command.aggregate.ln

聚合操作符。计算给定数字在自然对数值。

语法如下：

db.command.aggregate.ln(<number>)

<number> 可以是任意解析为非负数字的表达式。

ln 等价于 log([<number>, Math.E])，其中 Math.E 是 JavaScript 获取 e 的值的方法。

log

聚合操作符。计算给定数字在给定对数底下的 log 值。

API 说明

语法如下：

db.command.aggregate.log([<number>, <base>])

<number> 可以是任意解析为非负数字的表达式。<base> 可以是任意解析为大于 1 的数字的表达式。

如果任一参数解析为 null 或指向任意一个不存在的字段，log 返回 null。如果任一参数解析为 NaN，log 返回 NaN。

示例代码

假设集合 curve 有如下记录：

{ _id: 1, x: 1 }
{ _id: 2, x: 2 }
{ _id: 3, x: 3 }

计算 log2(x) 的值：

const $ = db.command.aggregate
db.collection('staff').aggregate()
  .project({
    log: $.log(['$x', 2])
  })
  .end()

返回结果如下：

{ _id: 1, log: 0 }
{ _id: 2, log: 1 }
{ _id: 3, log: 1.58496250072 }

log10

聚合操作符。计算给定数字在对数底为 10 下的 log 值。

API 说明

语法如下：

db.command.aggregate.log(<number>)

<number> 可以是任意解析为非负数字的表达式。

log10 等同于 log 方法的第二个参数固定为 10。

示例代码

db.command.aggregate.log10

聚合操作符。计算给定数字在对数底为 10 下的 log 值。

语法如下：

db.command.aggregate.log(<number>)

<number> 可以是任意解析为非负数字的表达式。

log10 等同于 log 方法的第二个参数固定为 10。

mod

聚合操作符。取模运算，取数字取模后的值。

API 说明

语法如下：

db.command.aggregate.mod([<dividend>, <divisor>])

第一个数字是被除数，第二个数字是除数。参数可以是任意解析为数字的表达式。

示例代码

假设集合 shopping 有如下记录：

{ _id: 1, bags: 3, items: 5 }
{ _id: 2, bags: 2, items: 8 }
{ _id: 3, bags: 5, items: 16 }

各记录取 items 除以 bags 的余数（items % bags）：

const $ = db.command.aggregate
db.collection('shopping').aggregate()
  .project({
    overflow: $.mod(['$items', '$bags'])
  })
  .end()

返回结果如下：

{ _id: 1, log: 2 }
{ _id: 2, log: 0 }
{ _id: 3, log: 1 }

multiply

聚合操作符。取传入的数字参数相乘的结果。

API 说明

语法如下：

db.command.aggregate.multiply([<expression1>, <expression2>, ...])

参数可以是任意解析为数字的表达式。

示例代码

假设集合 fruits 有如下记录：

{ "_id": 1, "name": "apple", "price": 10, "quantity": 100 }
{ "_id": 2, "name": "orange", "price": 15, "quantity": 50 }
{ "_id": 3, "name": "lemon", "price": 5, "quantity": 20 }

求各个水果的的总价值：

const $ = db.command.aggregate
db.collection('fruits').aggregate()
  .project({
    name: 1,
    total: $.multiply(['$price', '$quantity']),
  })
  .end()

返回结果如下：

{ "_id": 1, "name": "apple", "total": 1000 }
{ "_id": 2, "name": "orange", "total": 750 }
{ "_id": 3, "name": "lemo", "total": 100 }

pow

聚合操作符。求给定基数的指数次幂。

API 说明

语法如下：

db.command.aggregate.pow([<base>, <exponent>])

参数可以是任意解析为数字的表达式。

示例代码

假设集合 stats 有如下记录：

{ "_id": 1, "x": 2, "y": 3 }
{ "_id": 2, "x": 5, "y": 7 }
{ "_id": 3, "x": 10, "y": 20 }

求 x 和 y 的平方和：

const $ = db.command.aggregate
db.collection('stats').aggregate()
  .project({
    sumOfSquares: $.add([$.pow(['$x', 2]), $.pow(['$y', 2])]),
  })
  .end()

返回结果如下：

{ "_id": 1, "sumOfSquares": 13 }
{ "_id": 2, "sumOfSquares": 74 }
{ "_id": 3, "sumOfSquares": 500 }

sqrt

聚合操作符。求平方根。

API 说明

语法如下：

db.command.aggregate.sqrt([<number>])

参数可以是任意解析为非负数字的表达式。

示例代码

假设直角三角形集合 triangle 有如下记录：

{ "_id": 1, "x": 2, "y": 3 }
{ "_id": 2, "x": 5, "y": 7 }
{ "_id": 3, "x": 10, "y": 20 }

假设 x 和 y 分别为两直角边，则求斜边长：

const $ = db.command.aggregate
db.collection('triangle').aggregate()
  .project({
    len: $.sqrt([$.add([$.pow(['$x', 2]), $.pow(['$y', 2])])]),
  })
  .end()

返回结果如下：

{ "_id": 1, "len": 3.605551275463989 }
{ "_id": 2, "len": 8.602325267042627 }
{ "_id": 3, "len": 22.360679774997898 }

subtract

聚合操作符。将两个数字相减然后返回差值，或将两个日期相减然后返回相差的毫秒数，或将一个日期减去一个数字返回结果的日期。

API 说明

语法如下：

db.command.aggregate.subtract([<expression1>, <expression2>])

参数可以是任意解析为数字或日期的表达式。

示例代码

假设集合 scores 有如下记录：

{ "_id": 1, "max": 10, "min": 1 }
{ "_id": 2, "max": 7, "min": 5 }
{ "_id": 3, "max": 6, "min": 6 }

求各个记录的 max 和 min 的差值。：

const $ = db.command.aggregate
db.collection('scores').aggregate()
  .project({
    diff: $.subtract(['$max', '$min'])
  })
  .end()

返回结果如下：

{ "_id": 1, "diff": 9 }
{ "_id": 2, "diff": 2 }
{ "_id": 3, "diff": 0 }

trunc

聚合操作符。将数字截断为整形。

API 说明

语法如下：

db.command.aggregate.trunc(<number>)

参数可以是任意解析为数字的表达式。

示例代码

假设集合 scores 有如下记录：

{ "_id": 1, "value": 1.21 }
{ "_id": 2, "value": 3.83 }
{ "_id": 3, "value": -4.94 }

const $ = db.command.aggregate
db.collection('scores').aggregate()
  .project({
    int: $.trunc('$value')
  })
  .end()

返回结果如下：

{ "_id": 1, "value": 1 }
{ "_id": 2, "value": 3 }
{ "_id": 3, "value": -4 }

数组操作符

arrayElemAt

聚合操作符。返回在指定数组下标的元素。

API 说明

语法如下：

db.command.aggregate.arrayElemAt([<array>, <index>])

<array> 可以是任意解析为数字的表达式。

<index> 可以是任意解析为整形的表达式。如果是正数，arrayElemAt 返回在 index 位置的元素，如果是负数，arrayElemAt 返回从数组尾部算起的 index 位置的元素。

示例代码

假设集合 exams 有如下记录：

{ "_id": 1, "scores": [80, 60, 65, 90] }
{ "_id": 2, "scores": [78] }
{ "_id": 3, "scores": [95, 88, 92] }

求各个第一次考试的分数和和最后一次的分数：

const $ = db.command.aggregate
db.collection('exams').aggregate()
  .project({
    first: $.arraElemAt(['$scores', 0]),
    last: $.arraElemAt(['$scores', -1]),
  })
  .end()

返回结果如下：

{ "_id": 1, "first": 80, "last": 90 }
{ "_id": 2, "first": 78, "last": 78 }
{ "_id": 3, "first": 95, "last": 92 }

arrayToObject

聚合操作符。将一个数组转换为对象。

API 说明

语法可以取两种：

第一种：传入一个二维数组，第二维的数组长度必须为 2，其第一个值为字段名，第二个值为字段值

db.command.aggregate.arrayToObject([
  [<key1>, <value1>],
  [<key2>, <value2>],
  ...
])

第二种：传入一个对象数组，各个对象必须包含字段 k 和 v，分别指定字段名和字段值

db.command.aggregate.arrayToObject([
  { "k": <key1>, "v": <value1> },
  { "k": <key2>, "v": <value2> },
  ...
])

传入 arrayToObject 的参数只要可以解析为上述两种表示法之一即可。

示例代码

假设集合 shops 有如下记录：

{ "_id": 1, "sales": [ ["max", 100], ["min", 50] ] }
{ "_id": 2, "sales": [ ["max", 70], ["min", 60] ] }
{ "_id": 3, "sales": [ { "k": "max", "v": 50 }, { "k": "min", "v": 30 } ] }

求各个第一次考试的分数和和最后一次的分数：

const $ = db.command.aggregate
db.collection('shops').aggregate()
  .project({
    sales: $.arrayToObject('$sales'),
  })
  .end()

返回结果如下：

{ "_id": 1, "sales": { "max": 100, "min": 50 } }
{ "_id": 2, "sales": { "max": 70, "min": 60 } }
{ "_id": 3, "sales": { "max": 50, "min": 30 } }

concatArrays

聚合操作符。将多个数组拼接成一个数组。

API 说明

语法如下：

db.command.aggregate.arrayToObject([ <array1>, <array2>, ... ])

参数可以是任意解析为数组的表达式。

示例代码

假设集合 items 有如下记录：

{ "_id": 1, "fruits": [ "apple" ], "vegetables": [ "carrot" ] }
{ "_id": 2, "fruits": [ "orange", "lemon" ], "vegetables": [ "cabbage" ] }
{ "_id": 3, "fruits": [ "strawberry" ], "vegetables": [ "spinach" ] }

const $ = db.command.aggregate
db.collection('items').aggregate()
  .project({
    list: $.concatArrays(['$fruits', '$vegetables']),
  })
  .end()

返回结果如下：

{ "_id": 1, "list": [ "apple", "carrot" ] }
{ "_id": 2, "list": [ "orange", "lemon", "cabbage" ] }
{ "_id": 3, "list": [ "strawberry", "spinach" ] }

filter

聚合操作符。根据给定条件返回满足条件的数组的子集。

API 说明

语法如下：

db.command.aggregate.filter({
  input: <array>,
  as: <string>,
  cond: <expression>
})

参数可以是任意解析为数组的表达式。

示例代码

假设集合 fruits 有如下记录：

{
  "_id": 1,
  "stock": [
    { "name": "apple", "price": 10 },
    { "name": "orange", "price": 20 }
  ],
}
{
  "_id": 2,
  "stock": [
    { "name": "lemon", "price": 15 },
  ],
}

const _ = db.command
const $ = db.command.aggregate
db.collection('fruits').aggregate()
  .project({
    stock: $.filter({
      input: '$stock',
      as: 'item',
      cond: $.gte(['$$item.price', 15])
    })
  })
  .end()

返回结果如下：

{ "_id": 1, "stock": [ { "name": "orange", "price": 20} ] }
{ "_id": 2, "stock": [ { "name": "lemon", "price": 15 } ] }

in

聚合操作符。给定一个值和一个数组，如果值在数组中则返回 true，否则返回 false。

API 说明

语法如下：

db.command.aggregate.in([<value>, <array>])

<value> 可以是任意表达式。

<array> 可以是任意解析为数组的表达式。

示例代码

假设集合 shops 有如下记录：

{ "_id": 1, "topsellers": ["bread", "ice cream", "butter"] }
{ "_id": 2, "topsellers": ["ice cream", "cheese", "yagurt"] }
{ "_id": 3, "topsellers": ["croissant", "cucumber", "coconut"] }

标记销量最高的商品包含 ice cream 的记录。

const $ = db.command.aggregate
db.collection('price').aggregate()
  .project({
    included: $.in(['ice cream', '$topsellers'])
  })
  .end()

返回结果如下：

{ "_id": 1, "included": true }
{ "_id": 2, "included": true }
{ "_id": 3, "included": false }

indexOfArray

聚合操作符。在数组中找出等于给定值的第一个元素的下标，如果找不到则返回 -1。

API 说明

语法如下：

db.command.aggregate.indexOfArray([ <array expression>, <search expression>, <start>, <end> ])

参数可以是任意解析为数组的表达式。

示例代码

假设集合 stats 有如下记录：

{
  "_id": 1,
  "sales": [ 1, 6, 2, 2, 5 ]
}
{
  "_id": 2,
  "sales": [ 4, 2, 1, 5, 2 ]
}
{
  "_id": 3,
  "sales": [ 2, 5, 3, 3, 1 ]
}

const $ = db.command.aggregate
db.collection('stats').aggregate()
  .project({
    index: $.indexOfArray(['$sales', 2, 2])
  })
  .end()

返回结果如下：

{ "_id": 1, "index": 2 }
{ "_id": 2, "index": 4 }
{ "_id": 3, "index": -1 }

isArray

聚合操作符。判断给定表达式是否是数组，返回布尔值。

API 说明

语法如下：

db.command.aggregate.isArray(<expression>)

参数可以是任意表达式。

示例代码

假设集合 stats 有如下记录：

{
  "_id": 1,
  "base": 10,
  "sales": [ 1, 6, 2, 2, 5 ]
}
{
  "_id": 2,
  "base": 1,
  "sales": 100
}

计算总销量，如果 sales 是数字，则求 sales * base，如果 sales 是数组，则求数组元素之和与 base 的乘积。

const $ = db.command.aggregate
db.collection('stats').aggregate()
  .project({
    sum: $.cond({
      if: $.isArray('$sales'),
      then: $.multiply([$.sum(['$sales']), '$base']),
      else: $.multiply(['$sales', '$base']),
    })
  })
  .end()

返回结果如下：

{ "_id": 1, "index": 160 }
{ "_id": 2, "index": 100 }

map

聚合操作符。类似 JavaScript Array 上的 map 方法，将给定数组的每个元素按给定转换方法转换后得出新的数组。

API 说明

语法如下：

db.command.aggregate.map({
  input: <expression>,
  as: <string>,
  in: <expression>
})

示例代码

假设集合 stats 有如下记录：

{
  "_id": 1,
  "sales": [ 1.32, 6.93, 2.48, 2.82, 5.74 ]
}
{
  "_id": 2,
  "sales": [ 2.97, 7.13, 1.58, 6.37, 3.69 ]
}

将各个数字截断为整形，然后求和

const $ = db.command.aggregate
db.collection('stats').aggregate()
  .project({
    truncated: $.map({
      input: '$sales',
      as: 'num',
      in: $.trunc('$$num'),
    })
  })
  .project({
    total: $.sum('$truncated')
  })
  .end()

返回结果如下：

{ "_id": 1, "index": 16 }
{ "_id": 2, "index": 19 }

objectToArray

聚合操作符。将一个对象转换为数组。方法把对象的每个键值对都变成输出数组的一个元素，元素形如 { k: <key>, v: <value> }。

API 说明

语法如下：

db.command.aggregate.objectToArray(<object>)

示例代码

假设集合 items 有如下记录：

{ "_id": 1, "attributes": { "color": "red", "price": 150 } }
{ "_id": 2, "attributes": { "color": "blue", "price": 50 } }
{ "_id": 3, "attributes": { "color": "yellow", "price": 10 } }

const $ = db.command.aggregate
db.collection('items').aggregate()
  .project({
    array: $.objectToArray('$attributes')
  })
  .end()

返回结果如下：

{ "_id": 1, "array": [{ "k": "color", "v": "red" }, { "k": "price", "v": 150 }] }
{ "_id": 2, "array": [{ "k": "color", "v": "blue" }, { "k": "price", "v": 50 }] }
{ "_id": 3, "array": [{ "k": "color", "v": "yellow" }, { "k": "price", "v": 10 }] }

range

聚合操作符。返回一组生成的序列数字。给定开始值、结束值、非零的步长，range 会返回从开始值开始逐步增长、步长为给定步长、但不包括结束值的序列。

API 说明

语法如下：

db.command.aggregate.range([<start>, <end>, <non-zero step>])

示例代码

假设集合 stats 有如下记录：

{ "_id": 1, "max": 52 }
{ "_id": 2, "max": 38 }

const $ = db.command.aggregate
db.collection('stats').aggregate()
  .project({
    points: $.range([0, '$max', 10])
  })
  .end()

返回结果如下：

{ "_id": 1, "points": [0, 10, 20, 30, 40, 50] }
{ "_id": 2, "points": [0, 10, 20] }

reduce

聚合操作符。类似 JavaScript 的 reduce 方法，应用一个表达式于数组各个元素然后归一成一个元素。

API 说明

语法如下：

db.command.aggregate.reduce({
  input: <array>
  initialValue: <expression>,
  in: <expression>
})

示例代码

简易字符串拼接

假设集合 player 有如下记录：

{ "_id": 1, "fullname": [ "Stephen", "Curry" ] }
{ "_id": 2, "fullname": [ "Klay", "Thompsom" ] }

获取各个球员的全名，并加 Player: 前缀：

const $ = db.command.aggregate
db.collection('player').aggregate()
  .project({
    info: $.reduce({
      input: '$fullname',
      initialValue: 'Player:',
      in: $.concat(['$$value', ' ', '$$this']),
    })
  })
  .end()

返回结果如下：

{ "_id": 1, "info": "Player: Stephen Curry" }
{ "_id": 2, "info": "Player: Klay Thompson" }

获取各个球员的全名，不加前缀：

const $ = db.command.aggregate
db.collection('player').aggregate()
  .project({
    name: $.reduce({
      input: '$fullname',
      initialValue: '',
      in: $.concat([
        '$$value',
        $.cond({
          if: $.eq(['$$value', '']),
          then: '',
          else: ' ',
        }),
        '$$this',
      ]),
    })
  })
  .end()

返回结果如下：

{ "_id": 1, "name": "Stephen Curry" }
{ "_id": 2, "name": "Klay Thompson" }

reverseArray

聚合操作符。返回给定数组的倒序形式。

API 说明

语法如下：

db.command.aggregate.reverseArray(<array>)

参数可以是任意解析为数组表达式。

示例代码

假设集合 stats 有如下记录：

{
  "_id": 1,
  "sales": [ 1, 2, 3, 4, 5 ]
}

取 sales 倒序：

const $ = db.command.aggregate
db.collection('stats').aggregate()
  .project({
    reversed: $.reverseArray('$sales'),
  })
  .end()

返回结果如下：

{ "_id": 1, "reversed": [5, 4, 3, 2, 1] }

size

聚合操作符。返回数组长度。

API 说明

语法如下：

db.command.aggregate.size(<array>)

<array> 可以是任意解析为数组的表达式。

示例代码

假设集合 shops 有如下记录：

{ "_id": 1, "staff": [ "John", "Middleton", "George" ] }
{ "_id": 2, "staff": [ "Steph", "Jack" ] }

计算各个商店的雇员数量：

const $ = db.command.aggregate
db.collection('staff').aggregate()
  .project({
    totalStaff: $.size('$staff')
  })
  .end()

返回结果如下：

{ "_id": 1, "totalStaff": 3 }
{ "_id": 2, "totalStaff": 2 }

slice

聚合操作符。类似 JavaScritp 的 slice 方法。返回给定数组的指定子集。

API 说明

语法有两种：

返回从开头或结尾开始的 n 个元素：

db.command.aggregate.slice([<array>, <n>])

返回从指定位置算作数组开头、再向后或向前的 n 个元素：

db.command.aggregate.slice([<array>, <position>, <n>])

<array> 可以是任意解析为数组的表达式。

<position> 可以是任意解析为整形的表达式。如果是正数，则将数组的第 <position> 个元素作为数组开始；如果 <position> 比数组长度更长，slice 返回空数组。如果是负数，则将数组倒数第 <position> 个元素作为数组开始；如果 <position> 的绝对值大于数组长度，则开始位置即为数组开始位置。

<n> 可以是任意解析为整形的表达式。如果 <position> 有提供，则 <n> 必须为正整数。如果是正数，slice 返回前 n 个元素。如果是负数，slice 返回后 n 个元素。

示例代码

假设集合 people 有如下记录：

{ "_id": 1, "hobbies": [ "basketball", "football", "tennis", "badminton" ] }
{ "_id": 2, "hobbies": [ "golf", "handball" ] }
{ "_id": 3, "hobbies": [ "table tennis", "swimming", "rowing" ] }

统一返回前两个爱好：

const $ = db.command.aggregate
db.collection('fruits').aggregate()
  .project({
    hobbies: $.slice(['$hobbies', 2]),
  })
  .end()

返回结果如下：

{ "_id": 1, "hobbies": [ "basketball", "football" ] }
{ "_id": 2, "hobbies": [ "golf", "handball" ] }
{ "_id": 3, "hobbies": [ "table tennis", "swimming" ] }

zip

聚合操作符。把二维数组的第二维数组中的相同序号的元素分别拼装成一个新的数组进而组装成一个新的二维数组。如可将 [ [ 1, 2, 3 ], [ "a", "b", "c" ] ] 转换成 [ [ 1, "a" ], [ 2, "b" ], [ 3, "c" ] ]。

API 说明

语法如下：

db.command.aggregate.zip({
  inputs: [<array1>, <array2>, ...],
  useLongestLength: <boolean>,
  defaults: <array>
})

inputs 是一个二维数组（inputs 不可以是字段引用），其中每个元素的表达式（这个可以是字段引用）都可以解析为数组。如果其中任意一个表达式返回 null，<inputs> 也返回 null。如果其中任意一个表达式不是指向一个合法的字段 / 解析为数组 / 解析为 null，则返回错误。

useLongestLength 决定输出数组的长度是否采用输入数组中的最长数组的长度。默认为 false，即输入数组中的最短的数组的长度即是输出数组的各个元素的长度。

defaults 是一个数组，用于指定在输入数组长度不一的情况下时采用的数组各元素默认值。指定这个字段则必须指定 useLongestLength，否则返回错误。如果 useLongestLength 是 true 但是 defaults 是空或没有指定，则 zip 用 null 做数组元素的缺省默认值。指定各元素默认值时 defaults 数组的长度必须是输入数组最大的长度。

示例代码

假设集合 stats 有如下记录：

{ "_id": 1, "zip1": [1, 2], "zip2": [3, 4], "zip3": [5, 6] ] }
{ "_id": 2, "zip1": [1, 2], "zip2": [3], "zip3": [4, 5, 6] ] }
{ "_id": 3, "zip1": [1, 2], "zip2": [3] ] }

只传 inputs

const $ = db.command.aggregate
db.collection('items').aggregate()
  .project({
    zip: $.zip({
      inputs: [
        '$zip1', // 字段引用
        '$zip2',
        '$zip3',
      ],
    })
  })
  .end()

返回结果如下：

{ "_id": 1, "zip": [ [1, 3, 5], [2, 4, 6] ] }
{ "_id": 2, "zip": [ [1, 3, 4] ] }
{ "_id": 3, "zip": null }

设置 useLongestLength

如果设 useLongestLength 为 true：

const $ = db.command.aggregate
db.collection('items').aggregate()
  .project({
    zip: $.zip({
      inputs: [
        '$zip1', // 字段引用
        '$zip2',
        '$zip3',
      ],
      useLongestLength: true,
    })
  })
  .end()

返回结果如下：

{ "_id": 1, "zip": [ [1, 3, 5], [2, 4, 6] ] }
{ "_id": 2, "zip": [ [1, 3, 4], [2, null, 5], [null, null, 6] ] }
{ "_id": 3, "zip": null }

设置 defaults

const $ = db.command.aggregate
db.collection('items').aggregate()
  .project({
    zip: $.zip({
      inputs: [
        '$zip1', // 字段引用
        '$zip2',
        '$zip3',
      ],
      useLongestLength: true,
      defaults: [-300, -200, -100],
    })
  })
  .end()

返回结果如下：

{ "_id": 1, "zip": [ [1, 3, 5], [2, 4, 6] ] }
{ "_id": 2, "zip": [ [1, 3, 4], [2, -200, 5], [-300, -200, 6] ] }
{ "_id": 3, "zip": null }