mongodb聚合管道中常见聚合函数的参考与演示——按顺序排序

说明

仅为个人整理及理解，大多数都是参照官方文档，记录只是为了加深印象而已，有些数学函数未作测试，有些做了测试也还是没能理解这个函数有什么用...

未做测试的函数（大多为数学三角函数、方差函数）：accumulator、acos、acosh、asin、asinh、atan、atan2、atanh、cos、cosh、covariancePop 、covarianceSamp、degreesToRadians、degreesRank、derivative、expMovingAvg、function、sin、sinh、stdDevSamp、tan、tanh

参考：Aggregation Pipeline Operators — MongoDB Manual

点击查看按照分类整理的

数据准备

use test
data = [
  { _id: 1, name: 'tom', sex: '男', score:{yw:100,sx:50}, age: 34,update_at:1533657600000,create_at:1520481600000,favorites: [ "chocolate", "cake"]},
  { _id: 2, name: 'jeke', sex: '男', score:{yw:90,sx:60}, age: 24,update_at:1533657600000,create_at:1520478000000,favorites: [ "chocolate", "apples" ]},
  { _id: 3, name: 'kite', sex: '女', score:{yw:40,sx:70}, age: 36,update_at:1533657600000,create_at:1520514000000,favorites: [ "chocolate","butter", "apples" ]},
  { _id: 4, name: 'herry', sex: '男', score:{yw:90,sx:77}, age: 56,update_at:1533657600000,create_at:1520366400000,favorites: [ "cake", "butter"]},
  { _id: 5, name: 'marry', sex: '女', score:{yw:70,sx:55}, age: 18,update_at:1533657600000,create_at:1520474400000,favorites: ["cake","apples" ]},
  { _id: 6, name: 'john', sex: '男', score:{yw:100,sx:93}, age: 31 ,update_at:1533657600000,create_at:1520391600000,favorites: [ "butter"]}
]
db.students.insertMany(data)
data = [
  { _id: 1, province: 'GuangGong', country: 'China', detail: '幸福小区001弄',student_id:6},
  { _id: 2, province: 'Tokyo', country: 'Japan', detail: '幸福小区002弄',student_id:6},
  { _id: 3, province: 'ShangHai', country: 'China', detail: '幸福小区003弄',student_id:5},
  { _id: 4, province: 'BeiJing', country: 'China', detail: '幸福小区004弄',student_id:4},
  { _id: 5, province: 'MingGuWu', country: 'Japan', detail: '幸福小区005弄',student_id:3},
  { _id: 6, province: 'XiNi', country: 'Australia', detail: '幸福小区006弄',student_id:2},
  { _id: 7, province: 'NewYork', country: 'America', detail: '幸福小区006弄',student_id:1},
]
db.address.insertMany(data)
# 查看数据
db.students.find().limit(1)
db.address.find().limit(1)

注意时间戳这里存的是以毫秒为单位的，让我们查看其中一条数据

聚合函数

abs—求绝对值

如求学生的数学成绩与60之间的绝对值

xxxxxxxxxx
db.students.aggregate([{
    $project: {
        abs_age: {
            $abs: {
                $subtract:['$score.sx',60]
            }
        }
    }
}])

add—数字或日期相加

求学生的数学成绩与语文成绩总和，并将创建时间添加一天

添加时间时默认单位时毫秒，一天间隔 86400000 毫秒

xxxxxxxxxx
db.students.aggregate([{
    $project: {
        abs_age: {
            $add:['$score.sx','$score.yw']
        },
        create_at:1,
        create_at_now:{
            $add:['$create_at',86400000]
        }
    }
}])

addToSet—返回唯一值数组

仅支持在 $bucket、$bucketAuto、$group、$setWindowField这四个管道中使用

我们这里把Set理解成不重复的数组就很好理解了

如根据sex字段进行分组，并输出对应的年龄和语文成绩

xxxxxxxxxx
db.students.aggregate([{
    $group: {
        _id:'$sex',
        all_age:{$addToSet:'$age'},
        all_sx:{$addToSet:'$score.yw'}
    }
}])

allElementsTrue—判断所有元素是否全为True

xxxxxxxxxx
True：true、1、[]、str
False：false、0、null、undefined

官方例子

xxxxxxxxxx
# 数据准备
db.survey.insertMany([
   { "_id" : 1, "responses" : [ true ] },
   { "_id" : 2, "responses" : [ true, false ] },
   { "_id" : 3, "responses" : [ ] },
   { "_id" : 4, "responses" : [ 1, true, "seven" ] },
   { "_id" : 5, "responses" : [ 0 ] },
   { "_id" : 6, "responses" : [ [ ] ] },
   { "_id" : 7, "responses" : [ [ 0 ] ] },
   { "_id" : 8, "responses" : [ [ false ] ] },
   { "_id" : 9, "responses" : [ null ] },
   { "_id" : 10, "responses" : [ undefined ] }
])
# 查询输出
db.survey.aggregate(
   [
     { $project: { responses: 1, isAllTrue: { $allElementsTrue: [ "$responses" ] }, _id: 0 } }
   ]
)

and—bool运算且

简单例子

​x
True：true、1、[]、str
False：false、0、null、undefined

{ $and: [ 1, "green" ] }                    true
{ $and: [ ] }                               true
{ $and: [ [ null ], [ false ], [ 0 ] ] }    true
{ $and: [ null, true ] }                    false
{ $and: [ 0, true ] }                       false

查找语文、数学成绩都超过60（及格）的学生

xxxxxxxxxx
db.students.aggregate([{
    $match: {
        $and:[
            {'score.yw':{$gte:60}},
            {'score.sx':{$gte:60}},
        ]
    }
}])

anyElementTrue—判断所有元素是否有一个为True

xxxxxxxxxx
True：true、1、[]、str
False：false、0、null、undefined

官方例子

xxxxxxxxxx
db.survey.aggregate(
   [
     { $project: { responses: 1, isAnyTrue: { $anyElementTrue: [ "$responses" ] }, _id: 0 } }
   ]
)

arrayElemAt—获取数组的指定下标值

下标-1即倒数第一个，-2即倒数第二个，依次往下

xxxxxxxxxx
db.students.aggregate([{
    $project: {
        first:{$arrayElemAt:['$favorites',0]},
        last:{$arrayElemAt:['$favorites',-1]},
        index2:{$arrayElemAt:['$favorites',2]},
        'index-2':{$arrayElemAt:['$favorites',-2]},
    }
}])

arrayToObject—将数组转换成对象

xxxxxxxxxx
db.students.aggregate([{
    $project: {
        new_arr:{$arrayToObject:'$favorites'}
    }
}])

avg—求平均值

仅支持在$addFields、$bucket、$bucketAuto、$group、$match、$project、$replaceRoot、$replaceWith、$set、$setWindowField这几个管道中使用

查看学生平均成绩

xxxxxxxxxx
db.students.aggregate([{
    $project: {
        age_avg:{
            $avg:['$score.sx','$score.yw']
        }
    }
}])

binarySize—查看字符串或二进制数据的内容大小（以字节为单位）

版本要求：v4.4+

官方例子

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        bs_str:{
            $binarySize:'abcdEFG'
        },
        bs_str2:{
            $binarySize:'Hello World!'
        },
        bs_str3:{
            $binarySize:'!！！!'
        },
        bs_str4:{
            $binarySize:'cafétéria'
        },
        bs_str5:{
            $binarySize:"€λG"
        },
        bs_str6:{
            $binarySize:'你好'
        },
        bs_bytes:{
            $binarySize:new BinData(0, "MyIRAFVEd2aImaq7zN3u/w==")
        },
    }
},
{$limit:1}
])

空格占1字节、中文符号占1字节、é占2字节、€占3字节λ占2字节、汉字占3字节

bsonSize—查看文档大小

版本要求：v4.4+

$$ROOT表示当前文档根目录，即整个文档

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        bs:{
            $bsonSize:'$$ROOT'
        }
    }
}
])

ceil—向上取整

xxxxxxxxxx
db.students.aggregate([{
    $project: {
        age_divide:{$divide:['$age',10]},
        age_ceil:{
            $ceil:{
                $divide:['$age',10]
            }
        }
    },
}])

cmp—比较两个数并返回

如a、b，若a大于b则返回1，a小于b则返回-1，a等于b则返回0

xxxxxxxxxx
db.students.aggregate([{
    $project: {
        yw:'$score.yw',
        sx:'$score.sx',
        score_cmp:{
            $cmp:['$score.yw','$score.sx']
        }
    },
}])

concat—链接字符串并返回结果

仅支持字符串链接，若为其他类型请先转成字符串

xxxxxxxxxx
db.students.aggregate([{
    $project: {
        score_cmp:{
            $concat:[
                '$name',
                '成绩——语文：',
                {$toString:'$score.yw'},
                '，数学：'
                ,{$toString:'$score.sx'}
            ]
        }
    },
}])

concatArrays—链接数组并返回结果

为每个学生添加 ['pear','bear']

xxxxxxxxxx
db.students.aggregate([{
    $project: {
        score_cmp:{
            $concatArrays:[
                '$favorites',
                ['pear','bear']
            ]
        }
    },
}])

cond—条件判断，if else

语法：{ $cond: { if: <boolean-expression>, then: <true-case>, else: <false-case> } }

简写：{ $cond: [ <boolean-expression>, <true-case>, <false-case> ] }

xxxxxxxxxx
db.students.aggregate([{
    $project: {
        evaluate:{
            $cond:{
                if:{$gte:['$score.sx',60]},
                then:'及格',
                else:'不及格'
            }
        }
    },
}])

# 或者
db.students.aggregate([{
    $project: {
        evaluate:{
            $cond:[
                {$gte:['$score.sx',60]},
                '及格',
                '不及格'
            ]
        }
    },
}])

convert—转换类型

to类型：double、string、objectId、bool、date、int、long、decimal 严格区分大小写

xxxxxxxxxx
db.students.aggregate([{
    $project: {
        toInt:{
            $convert:{input:'333',to:'int'}
        },
        toDecimal:{
            $convert:{input:'3.33',to:'decimal'}
        },
        toObjectId:{
            $convert:{input:'625fdc38036ba2d828afdae0',to:'objectId'}
        },
        toBool:{
            $convert:{input:'0',to:'bool'}
        },
        toDate:{
            $convert:{input:'2022-02-22',to:'date'}
        },
        OnError:{
            $convert:{input:'3.33',to:'int',onError:'转换出错,指定转换类型错误'}
        },
        OnNull:{
            $convert:{input:null,to:'date',onNull:'输入值为null'}
        }
    }
}])

count—获取文档总数

版本要求：5.0+

仅支持在 $bucket、$bucketAuto、$group、$setWindowField这四个管道中使用

如分组后获取总数

xxxxxxxxxx
db.students.aggregate([{
    $group:{
        _id:'$sex',
        count:{$count:{}}
    }
}])

dateAdd—添加时间

版本要求：5.0+

更多请参考：$dateAdd (aggregation) — MongoDB Manual

startDate：初始时间，可以是时间类型、时间戳类型、ObjectId，但不能直接转换long类型

unit单位：year、quarter、week、month、day、hour、minute、second、millisecond

amount：正数为加，负数为减（dateSubtract效果）

timezone 一直测试不出来...，运行结果不达预期（bug?）

xxxxxxxxxx
db.students.aggregate([{
    $project:{
        create_at:1,
        create_at_date:{
            $toDate:'$create_at'
        },
        time_now:{
            $dateAdd:{
                 startDate: {$toDate:'$create_at'},
                 unit: "month",
                 amount: 1
              }
        }
    }
}])

dateDiff—比较两个时间的差

版本要求：5.0+

xxxxxxxxxx
{
   $dateDiff: {
      startDate: 时间1,
      endDate: 时间2,
      unit: 比较的单位year、quarter、week、month、day、hour、minute、second、millisecond,
      timezone: 时区、可选参数,
      startOfWeek: 一周的开始、默认是星期天、可选参数
   }
}

如比较创建时间和最新更新时间，看看两者之间隔了多少月或多少周

xxxxxxxxxx
db.students.aggregate([{
    $project:{
        diff_month:{
            $dateDiff:{
                 startDate: {$toDate:'$create_at'},
                 endDate: {$toDate:'$update_at'},
                 unit: "month"
              }
        },
        diff_month:{
            $dateDiff:{
                 startDate: {$toDate:'$update_at'},
                 endDate: {$toDate:'$create_at'},
                 unit: "month"
              }
        },
        diff_week_sunday:{
            $dateDiff:{
                 startDate: ISODate('2018-08-08'),
                 endDate: ISODate('2020-08-08'),
                 unit: "week"
              }
        },
        diff_week_friday:{
            $dateDiff:{
                 startDate: ISODate('2018-08-08'),
                 endDate: ISODate('2020-08-08'),
                 unit: "week",
                 startOfWeek:'friday'
              }
        }
    }
}])

dateFromParts—根据指定时间参数转换为时间类型

xxxxxxxxxx
{
    $dateFromParts : {
        'year': <year> 必填, 'month': <month> 1-12, 'day': <day> 1-31,
        'hour': <hour> 0-23, 'minute': <minute> 0-59, 'second': <second> 0-59,
        'millisecond': <ms> 0-999, 'timezone': <tzExpression>
    }
}
或者
{
    $dateFromParts : {
        'isoWeekYear': <year> 必填, 'isoWeek': <week> 0-55, 'isoDayOfWeek': <day> 1-7,
        'hour': <hour>, 'minute': <minute>, 'second': <second>,
        'millisecond': <ms>, 'timezone': <tzExpression>
    }
}

year和month是固定出现的，isoWeekYear、isoWeek、isoDayOfWeek也是固定出现的不能混起来使用

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        time_year:{
            $dateFromParts:{'year':2018,'month':8,'day':8}
        },
        time_isoYear:{
            $dateFromParts:{'isoWeekYear':2018,'isoWeek':8,'isoDayOfWeek':1}
        }
    }
},
{$limit:1}
])

dateFromString—从字符串转换成事件类型

xxxxxxxxxx
{ 
    $dateFromString: {
         dateString: 时间字符串,
         format: dateString 的格式、可选,
         timezone: 时区、可选,
         onError: 转换失败处理、可选,
         onNull: 转换空值处理、可选
    } 
}

#   2018-08-08T08:08:08.888
#   %Y-%m-%dT%H-%M-%S.%L
#   %Y：year %m：month    %d：day  %H：hour %M：minute   %S：second   %L：milliSecond
#   %G：ISOYear  %u：DayofWeek    %V：WeekOfYear   %z：时区间隔 %Z：失去间隔 %%：%符号
#   mongodb又自己搞了一套format，就不能统一一下吗

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        time1:{
            $dateFromString:{dateString:'2018-08-08T08:08:08.888'}
        },
        time2:{
            $dateFromString:{dateString:"2021/8/18"}
        },
        time_error:{
            $dateFromString:{
                dateString:"06-15-2018",
                onError:'转换失败'
            }
        },
        time_format:{
            $dateFromString:{
                dateString:"06-15-2018",
                format:'%m-%d-%Y'
            }
        },
        time_numm:{
            $dateFromString:{
                dateString:null,
                onNull:'空值'
            }
        }
    }
},
{$limit:1}
])

dateSubtract—递减时间

版本要求：5.0+

startDate：初始时间，可以是时间类型、时间戳类型、ObjectId，但不能直接转换long类型

unit单位：year、quarter、week、month、day、hour、minute、second、millisecond

amount：正数为减，负数为加（dateAdd效果）

xxxxxxxxxx
db.students.aggregate([{
    $project:{
        create_at:1,
        create_at_date:{
            $toDate:'$create_at'
        },
        time_next_month:{
            $dateSubtract:{
                 startDate: {$toDate:'$create_at'},
                 unit: "month",
                 amount: -1
              }
        },
        time_last_month:{
            $dateSubtract:{
                 startDate: {$toDate:'$create_at'},
                 unit: "month",
                 amount: 1
              }
        },
    }
}])

dateToParts—将时间解析成各个时间组成部分

将一个时间类型的值返回year、month、day、hour、minute、second、millisecond，若指定了iso8601为true，则会返回isoWeekYear、isoWeek、 isoDayOfWeek、hour、minute、second、millisecond。

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        date_parts:{
            $dateToParts:{
                date:{$toDate:'$create_at'}
            }
        },
        date_iso_parts:{
            $dateToParts:{
                date:{$toDate:'$create_at'},
                iso8601:true
            }
        },
        date_zone_parts:{
            $dateToParts:{
                date:{$toDate:'$create_at'},
                timezone:'+0800'
            }
        },
    }
},
{$limit:1}
])

dateToString—日期转字符串

xxxxxxxxxx
{ 
    $dateToString: {
        date: 要转换的时间,
        format: 转换格式、可选,
        timezone: 时区、可选,
        onNull: 为null时处理、可选
    } 
}
#   2018-08-08T08:08:08.888
#   %Y-%m-%dT%H-%M-%S.%L
#   %Y：year %m：month    %d：day  %H：hour %M：minute   %S：second   %L：milliSecond
#   %G：ISOYear  %u：DayofWeek    %V：WeekOfYear   %z：时区间隔 %Z：失去间隔 %%：%符号

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        date_str:{
            $dateToString:{
                date:{$toDate:'$create_at'}
            }
        },
        date_format_str:{
            $dateToString:{
                date:{$toDate:'$create_at'},
                format:'%d-%m-%Y'
            }
        },
        date_zone_str:{
            $dateToString:{
                date:{$toDate:'$create_at'},
                timezone:'+0800'
            }
        },
        date_null_str:{
            $dateToString:{
                date:null,
                onNull:'为空值'
            }
        }
    }
},
{$limit:1}
])

dateTrunc—截断日期

版本要求：v5.0+ 参考：$dateTrunc (aggregation) — MongoDB Manual

unit可指定：

year——当年的1月1日，无时间

quarter——当年当季的第一月1日，无时间

week——当年当周的第一天，无时间

month——当年当月1日，无时间

day——当年当月当日，无时间

hour——当年当月当日当时，无分秒

minute——当年当月当日当时分，无秒

second——当年当月当日当时分秒，无毫秒

binSize 一直没试成功，运行结果和自己预期的结果大相径庭，但又不知道怎么回事（bug?）

xxxxxxxxxx
db.students.aggregate([
{
    $project:{date_now:new Date("2020-05-18T14:10:30.888Z")}
},
{
    $project:{
        trunc_s:{
            $dateTrunc:{date:'$date_now',unit:'second'}
        },
        trunc_s2:{
            $dateTrunc:{date:'$date_now',unit:'second', binSize:30}
        },
        trunc_s3:{
            $dateTrunc:{date:'$date_now',unit:'second', binSize:60}
        }
    }
},{$limit:1}
])

xxxxxxxxxx
db.students.aggregate([
{
    $project:{date_now:new Date("2020-05-18T14:10:30.888Z")}
},
{
    $project:{
        trunc_m:{
            $dateTrunc:{date:'$date_now',unit:'minute'}
        },
        trunc_m2:{
            $dateTrunc:{date:'$date_now',unit:'minute', binSize:10}
        },
        trunc_m3:{
            $dateTrunc:{date:'$date_now',unit:'minute', binSize:60}
        },
        trunc_h:{
            $dateTrunc:{date:'$date_now',unit:'hour'}
        },
        trunc_h2:{
            $dateTrunc:{date:'$date_now',unit:'hour',   binSize:14}
        },
        trunc_h3:{
            $dateTrunc:{date:'$date_now',unit:'hour',   binSize:24}
        }
    }
},{$limit:1}
])

xxxxxxxxxx
db.students.aggregate([
{
    $project:{date_now:new Date("2020-05-18T14:10:30.888Z")}
},
{
    $project:{
        trunc_d:{
            $dateTrunc:{date:'$date_now',unit:'quarter'}
        },
        trunc_d2:{
            $dateTrunc:{date:'$date_now',unit:'quarter',binSize:2}
        },
        trunc_m:{
            $dateTrunc:{date:'$date_now',unit:'week'}
        },
        trunc_m2:{
            $dateTrunc:{date:'$date_now',unit:'week',binSize:10}
        },
        trunc_y:{
            $dateTrunc:{date:'$date_now',unit:'year'}
        },
        trunc_y2:{
            $dateTrunc:{date:'$date_now',unit:'year',binSize:10}
        }
    }
},{$limit:1}
])

xxxxxxxxxx
db.students.aggregate([
{
    $project:{date_now:new Date("2020-05-18T14:10:30.888Z")}
},
{
    $project:{
        trunc_q:{
            $dateTrunc:{date:'$date_now',unit:'day'}
        },
        trunc_q2:{
            $dateTrunc:{date:'$date_now',unit:'day',binSize:18}
        },
        trunc_q3:{
            $dateTrunc:{date:'$date_now',unit:'day',binSize:31}
        },
        trunc_w:{
            $dateTrunc:{date:'$date_now',unit:'month'}
        },
        trunc_w2:{
            $dateTrunc:{date:'$date_now',unit:'month',binSize:5}
        },
        trunc_w3:{
            $dateTrunc:{date:'$date_now',unit:'month',binSize:12}
        }
    }
},{$limit:1}
])

dayOfMonth—查询一月之中的第几天、0-31

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        day:{
            $dayOfMonth:{
                date:{$toDate:'$create_at'}
            }
        },
        day_timezone:{
            $dayOfMonth:{
                date:{$toDate:'$create_at'},
                timezone:'+0800'
            }
        },
    }
}
])

dayOfWeek—查询一周之中的第几天，1-7

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        day_week:{
            $dayOfWeek:{
                date:{$toDate:'$create_at'}
            }
        },
        day_week_timezone:{
            $dayOfWeek:{
                date:{$toDate:'$create_at'},
                timezone:'+0800'
            }
        },
    }
}
])

dayOfYear—查询一年之中的第几天，0-365

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        day_Year:{
            $dayOfYear:{
                date:{$toDate:'$create_at'}
            }
        },
        day_Year_timezone:{
            $dayOfYear:{
                date:{$toDate:'$create_at'},
                timezone:'+0800'
            }
        },
    }
}
])

divide—两数相除

前者除以后者，如学生的年龄除以10

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        age:1,
        age_10:{
            $divide:['$age',10]
        },
    }
}
])

documentNumber—返回文档在 $setWindowFields 阶段分区中的位置（称为文档编号）

版本要求：5.0+

仅支持在setWindowFields阶段中使用，不知道有什么用...

xxxxxxxxxx
db.students.aggregate([
{
    $project:{sex:1,age:1}
},
{
    $setWindowFields:{
        partitionBy:'$sex',
        sortBy:{age:-1},
        output:{
            result:{
                $documentNumber: {}
            }
        }
    }
}
])

eq—判断两值相等

相等返回True，否则返回false

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        age:'$age',
        age_is_18:{
            $eq:['$age',18]
        },
        eq_result:{
            $eq:['18',18]
        },
        eq_result2:{
            $eq:[null,null]
        },
    }
}
])

exp—提高欧拉数(即e) 到指定的 index

不知道有什么用

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        exp0:{
            $exp:0
        },
        exp2:{
            $exp:2
        },
        exp10:{
            $exp:10
        },
    }
}
,{$limit:1}
])

filter—过滤数组

基础语法

xxxxxxxxxx
{ 
    $filter: { 
        input: 数组, 
        as: 数组里每个元素, 
        cond: 过滤条件 
    } 
}

查询学生爱好中包含"apples"选项

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        favorites:1,
        target_filter:{
            $filter:{
                input:'$favorites',
                as:'item',
                cond:{
                    $eq:['$$item','apples']
                }
            }
        }
    }
}
])

first—获取第一个元素，常用于数组

版本要求：5.0+，与last取最后元素相对应

仅支持在bucket、bucketAuto、group、setWindowFields阶段中使用

如男生女生各取一名学生信息

xxxxxxxxxx
db.students.aggregate([
{
    $group:{
        _id:'$sex',
        info:{$first:'$$ROOT'}
    }
}
])

floor—向下取整

与ceil向上取整相对应

xxxxxxxxxx
db.students.aggregate([
{
    $group:{
        _id:'$sex',
        avg_age:{$avg:'$age'}
    }
},
{
    $project:{
        age_avg:'$avg_age',
        age_ceil:{$ceil:'$avg_age'},
        age_floor:{$floor:'$avg_age'},
    }
}
])

getField—获取某个字段的值

版本要求：5.0+，常用于处理含有.、$的字段

xxxxxxxxxx
{
  $getField: {
    field: <String>,
    input: <Object>、默认$$CURRENT、可选
  }
}

官方例子

xxxxxxxxxx
# 插入数据
db.inventory.insertMany( [
   { "_id" : 1,"price.usd": 45.99,"quantity": { "$small": 25}},
   { "_id" : 2,"price.usd": 499.99,"quantity": { "$small": 35}}
] )
# 删除数据
db.inventory.drop()

查询价格超过50的，并输出小号的数量

xxxxxxxxxx
db.inventory.aggregate([
{
    $match:{
        $expr:{
            $gt:[
                {$getField:{field:'price.usd',input:'$$CURRENT'}},
                50
            ]
        }
    }
},
{
    $project:{
        all_info:'$$ROOT',
        small_size:{
            $getField:{
                field:{$literal:"$small"},
                input:'$quantity'
            }
        }
    }
}
])

gt、gte—判断数值大于、大于等于某个值

与lt、lte小于、小于等于相对应

xxxxxxxxxx
db.students.aggregate([
{
    $match:{$expr:{
        $gt:['$age',18]
    }},
},{$project:{name:1}}
])

db.students.aggregate([
{
    $match:{$expr:{
        $gte:['$age',18]
    }}
},{$project:{name:1}}
])

###############################
#等同于
db.students.aggregate([
{
    $match:{
        age:{$gt:18}
    }
},{$project:{name:1}}
])

hour—获取时间中的小时值

xxxxxxxxxx
db.students.aggregate([
{   
    $project:{
        date:{$toDate:'$create_at'}
    }
},
{
    $project:{
        date:'$date',
        date_hour:{
            $hour:'$date'
        },
        date_hour_timezone:{
            $hour:{
                date:'$date',
                timezone:'+0800'
            }
        }
    }
}
])

ifNull—先判断空值再取值

版本要求：5.0+

如我们要取一个值，若Info字段不为null则取Info，否则取name字段，若name字段为null，则取favorites，我们可以这样写

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        stu_info:{
            $ifNull:["$info","$name","$age"]
        }
    }
}
])

in—判断数组是否包含某个元素

如查找喜欢吃“apples”的同学

xxxxxxxxxx
db.students.aggregate([
{
    $match:{
        $expr:{
            $in:[
                "apples",
                "$favorites"
            ]
        }
    }
},
{
    $project:{
        name:1,
        favorites:1
    }
}
])

indexOfArray—查询数组中指定元素

查询数组中指定元素，若包含指定元素则返回第一次出现的索引，若不包含则返回-1

基础语法

xxxxxxxxxx
{ 
    $indexOfArray: [ 
    <array expression> 数组, 
    <search expression> 指定元素, 
    <start> 开始查找的位置下标、默认0、可选, 
    <end> 结束查找的位置下标、默认结尾、可选] 
}

如查找favorites数组中apples出现的位置

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        favorites:1,
        fav_index:{
            $indexOfArray:['$favorites',"apples"]
        },
        fav_index_start:{
            $indexOfArray:['$favorites',"apples",2]
        },
        fav_index_end:{
            $indexOfArray:['$favorites',"apples",0,2]
        }
    }
}
])

# fav_index_start 从第三个开始查找（不查找前三个）
# fav_index_end 从第1个开始查找，第三个停止查找（只查找前三个）

indexOfBytes—查询字符串中指定字符串的索引位置

查询字符串中第一次出现的UTF-8字符并返回索引，若不包含则返回-1

基础语法

xxxxxxxxxx
{ 
    $indexOfBytes: [ 
    <string expression> 字符串, 
    <substring expression> 指定字符串, 
    <start> 开始查找的位置下标、默认0、可选, 
    <end> 结束查找的位置下标、默认结尾、可选] 
}

如查找学生名字带有a字符串的学生

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        name:1,
        name_index:{
            $indexOfBytes:['$name',"a"]
        },
        name_index_start:{
            $indexOfBytes:['$name',"a",2]
        },
        name_index_end:{
            $indexOfBytes:['$name',"a",0,2]
        }
    }
}
])

# name_index_start 从第三个开始查找（不查找前三个）
# name_index_end 从第1个开始查找，第三个停止查找（只查找前三个）

indexOfCP—查询字符串中指定字符串的索引位置

查询字符串中第一次出现的字符串并返回索引，若不包含则返回-1，不明白indexOfCP和indexOfBytes有什么区别

基础语法

xxxxxxxxxx
{ 
    $indexOfCP: [ 
    <string expression> 字符串, 
    <substring expression> 指定字符串, 
    <start> 开始查找的位置下标、默认0、可选, 
    <end> 结束查找的位置下标、默认结尾、可选] 
}

如查找学生名字带有a字符串的学生

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        name:1,
        name_index:{
            $indexOfCP:['$name',"a"]
        },
        name_index_start:{
            $indexOfCP:['$name',"a",2]
        },
        name_index_end:{
            $indexOfCP:['$name',"a",0,2]
        }
    }
}
])

# name_index_start 从第三个开始查找（不查找前三个）
# name_index_end 从第1个开始查找，第三个停止查找（只查找前三个）

isArray—判断是否为数组类型

固定语法：$isArray:[ 值 ] 注意值外面是用中括号包起来的

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        isArray:{
            $isArray:[
                [1,2,3]
            ]
        },
        isArray2:{
            $isArray:[
                [[1],2,"3"]
            ]
        },
        isArray3:{
            $isArray:[
                1
            ]
        },
    }
}
,{$limit:1}
])

isNumber—判断是否为数值类型

若类型为Integer、Decimal、Double、Long都属于数值类型，都返回true，其余都返回false

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        isNumber:{
            $isNumber:1
        },
        isNumber2:{
            $isNumber:NumberDecimal('1.2')
        },
        isNumber3:{
            $isNumber:NumberLong('120000000000000000')
        },
        isNumber4:{
            $isNumber:true
        },
        isNumber5:{
            $isNumber:'111'
        },
    }
}
,{$limit:1}
])

isoDayOfWeek—ISO 查询一周之中的第几天，1-7

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        date:{$toDate:'$create_at'},
        day:{
            $isoDayOfWeek:{
                date:{$toDate:'$create_at'}
            }
        },
        day_timezone:{
            $isoDayOfWeek:{
                date:{$toDate:'$create_at'},
                timezone:'+0800'
            }
        },
    }
}
])

isoWeek—ISO 查询一年之中的第几周，1-53

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        date:{$toDate:'$create_at'},
        day:{
            $isoWeek:{
                date:{$toDate:'$create_at'}
            }
        },
        day_timezone:{
            $isoWeek:{
                date:{$toDate:'$create_at'},
                timezone:'+0800'
            }
        },
    }
}
])

isoWeekYear—ISO 查询年份

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        date:{$toDate:'$create_at'},
        day:{
            $isoWeekYear:{
                date:{$toDate:'$create_at'}
            }
        },
        day_timezone:{
            $isoWeekYear:{
                date:{$toDate:'$create_at'},
                timezone:'+0800'
            }
        },
    }
}
])

last—取最后一个文档

版本要求：5.0+，与first取最后元素相对应

仅支持bucket、bucketAuto、group、setWindowFields阶段中使用

xxxxxxxxxx
db.students.aggregate([
{
    $group:{
        _id:'$sex',
        info:{$last:'$$ROOT'}
    }
}
])

last（Array）—取数组中最后一个元素

固定语法：$last:[ 值 ]—注意值外面是用中括号包起来的

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        last_item:{
            $last:[
                [1,2,3,4]
            ]
        },
        last_favorite:{
            $last:'$favorites'
        }
    }
}
])

let—声明变量操作变量

基础语法

xxxxxxxxxx
{
  $let:
     {
       vars: { <var1>: <expression>, ... 声明变量},
       in: <expression> 操作变量
     }
}

如获取语文、数学成绩总和然后判断总分评级，超过150则为优秀，否则为良好

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        
        ping_yu:{
            $let:{
                vars:{
                    total_score:{
                        $add:['$score.yw','$score.sx']
                    }
                },
                in:{
                    $cond:{
                        if:{$gt:['$$total_score',150]},
                        then:{$concat:['总分：',{$toString:'$$total_score'},',','优秀']},
                        else:{$concat:['总分：',{$toString:'$$total_score'},',','良好']},
                    }
                }
            }
        }
    }
}
])

literal—返回一个不进行解析的值

常用于含有.、$、1的字段，相当于一个转义符，在literal中.、$、1仅仅是个字符串，无特殊意义

官方例子

xxxxxxxxxx
# 插入数据
db.inventory.insertMany( [
   { "_id" : 1,"price.usd": 45.99,"quantity": { "$small": 25}},
   { "_id" : 2,"price.usd": 499.99,"quantity": { "$small": 35}}
] )

# 获取$small的尺码，默认输出订单数为1，在价格前面加$美元符号,并判断价格为$45.99的数据
db.inventory.aggregate([
{
    $project:{
        small_size_literal:{
            $getField:{
                field:{$literal:'$small'},
                input:'$quantity'
            }
        },
        order_literal:{
            $literal:1
        },
        price_literal:{
            $concat:[
                {$literal:'$'},
                {
                    $toString:{
                        $getField:{
                            field:'price.usd',
                            input:'$$CURRENT'
                        }
                    }
                }
                ]
        }
    }
},
{
    $match:{
        $expr:{
            $eq:[
                '$price_literal',
                {$literal:'$45.99'}
            ]
        }
    }
}
])

# 删除数据
db.inventory.drop()

ln—Log n计算对数

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        age:1,
        age_ln:{
            $ln:'$age'
        },
        ln_1:{
            $ln:1
        },
        ln_e:{
            $ln:Math.E
        },
        ln_10:{
            $ln:10
        },
        ln_null:{
            $ln:null
        }
    }
},{$limit:1}
])

log—log n 计算指定基数的对数

{$log:[数值,基数]}—基数要大于1

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        age:1,
        age_log:{
            $log:['$age',10]
        },
        log_1:{
            $log:[1,2]
        },
        log_100:{
            $log:[100,10]
        }
    }
},{$limit:1}
])

log10—计算基数为10的对数

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        age:1,
        age_log10:{
            $log10:'$age'
        },
        log10_1:{
            $log10:1
        },
        log10_100:{
            $log10:100
        }
    }
},{$limit:1}
])

lt、lte—判断数值小于、小于等于某个值

查询年龄小于50且数学成绩小于等于60的学生

xxxxxxxxxx
db.students.aggregate([
{
    $match:{
        $expr:{
            $and:[
                {$lt:['$age',50]},
                {$lte:['$score.sx',60]}
            ]
        }
    }
}
])

ltrim—去除左边的指定字符串、默认空格

基础语法，与rtrim相对应

xxxxxxxxxx
{ 
    $ltrim: { 
        input: <string> 字符串,  
        chars: <string> 去除的指定字符、默认空字符串、可选 
    } 
}

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        ltrim_str:{
            $ltrim:{input:'Hello World'}
        },
        ltrim_str_He:{
            $ltrim:{input:'He  llo World',chars:'He'}
        },
        ltrim_str_space:{
            $ltrim:{input:'\t \r\n Hello World'}
        },
    }
},{$limit:1}
])

map—遍历操作每个元素，并返回修改后的结果

基础语法，通常操作数组

xxxxxxxxxx
{ 
    $map: { 
        input: <expression> 数据源, 
        as: <string> 每个元素, 
        in: <expression> 操作元素 
    } 
}

如在favorites的每一项前加上"我喜欢"

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        favorites:'$favorites',
        favorites_map:{
            $map:{
                input:'$favorites',
                as:'item',
                in:{
                    $concat:['我喜欢','$$item']
                }
            }
        }
    }
},{$limit:1}
])

max—获取最大值

xxxxxxxxxx
db.students.aggregate([
{
    $group:{
        _id:'$sex',
        max_age:{
            $max:'$age'
        }
    }
},
{
    $project:{
        max_age:1,
        max_arr:{
            $max:[0,5,7,6,14,2,3]
        }
    }
}
])

mergeObjects—将多个文档合并为一个文档

仅支持bucket、bucketAuto、group、replaceRoot阶段中使用

若文档中有相同元素则以最后一个文档为主，不同元素会合并为一个对象

合并相同元素，如根据性别分组后合并成绩

xxxxxxxxxx
db.students.aggregate([
{
    $group:{
        _id:'$sex',
        score_all:{
            $push:'$score'
        },
        score_merge:{
            $mergeObjects:'$score'
        }
    }
}
])