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

点击查看按照顺序整理的

数据准备

xxxxxxxxxx
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]
        }
    }
}])

avg—求平均值

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

查看学生平均成绩

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

ceil—向上取整

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

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'},
    }
}
])

divide—两数相除

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

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

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

不知道有什么用

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

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}
])

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]
        }
    }
}
])

min—获取最小值

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

mod—两个数取余

注意：不能对0取余

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        age:1,
        mod_age:{
            $mod:['$age','$age']
        },
        mod_age_10:{
            $mod:['$age',10]
        },
        mod_0:{
            $mod:[0,'$age']
        },
        mod_1:{
            $mod:[1,'$age']
        },
    }
},{$limit:1}
])

multiply—两数相乘

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

pow—幂运算

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        pow_0:{
            $pow:[5,0]
        },
        pow_2:{
            $pow:[5,2]
        },
        'pow_-2':{
            $pow:[5,-2]
        }
    }
},{$limit:1}
])

rand—获取随机数，返回0-1之前的浮点数

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        rand:{
            $rand:{}
        },
        rand_0_5:{
            $ceil:{
                $multiply:[{$rand:{}},5]
            }
        }
    }
},{$limit:1}
])

round—四舍五入

基础语法

xxxxxxxxxx
{ 
    $round : [ 
        <number> 数据源, 
        <place> 保留几位小数点、-20至100之间、可选默认0
    ] 
}

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        round:{
            $round:[1.568475]
        },
        round_2:{
            $round:[1.568475,2]
        },
        'round_-2':{
            $round:[1.568475,-2]
        }
        
    }
},{$limit:1}
])

sqrt—计算正数的平方根

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        sqrt_result_25:{
            $sqrt:25
        },
        sqrt_result_100:{
            $sqrt:100
        },
        sqrt_result_88:{
            $sqrt:88
        },
    }
},{$limit:1}
])

subtract—两数相减返回差值

如查看学生年龄离30岁还有多远

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        age:1,
        age_substract:{
            $subtract:['$age',30]
        }
    }
}
])

sum—获取总数

仅支持addFields、bucket、bucketAuto、group、match、project、replaceRoot、replaceWith、set、setWindowFields阶段中使用

如按照学生性别分组，分别计算出数学、语文的总成绩

xxxxxxxxxx
db.students.aggregate([
{
    $group:{
        _id:'$sex',
        sx:{
            $sum:'$score.sx'
        },
        yw:{
            $sum:'$score.yw'
        }
    }
}
])

trunc—截取小数点，保留几位小数，默认不保留

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        trunc:{
            $trunc:[1.5555]
        },
        trunc_2:{
            $trunc:[3.33333,2]
        },
        trunc_3:{
            $trunc:[-6.666666,3]
        },
    }
},{$limit:1}
])

字符串相关聚合函数

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'
        }
    }
}
])

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

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

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

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个开始查找，第三个停止查找（只查找前三个）

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}
])

rtrim—去除右边的指定字符串、默认空格

基础语法，与ltrim去除左边相对应

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

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        rtrim_str:{
            $rtrim:{input:'Hello World'}
        },
        rtrim_str_He:{
            $rtrim:{input:'Hello World',chars:'ld'}
        },
        rtrim_str_space:{
            $rtrim:{input:'Hello World\t \r\n '}
        },
    }
},{$limit:1}
])

regexFind—正则查找

版本要求：4.2+

基础语法

xxxxxxxxxx
{ 
    $regexFind: { 
        input: <expression> 数据源, 
        regex: <expression> 正则表达式, 
        options: <expression> 选项、可选、i忽略大小写、m锚点或换行符优化、x忽略空白字符、s允许.匹配所有包括空白字符
    }
}
# m配置说明：添加m配置换行后也有可能命中开始或结束锚点，若数据源没有换行符或者正则表达式中没有锚点，那么此时指定m是无意义的
# 匹配成功返回
# { "match" : <string>, "idx" : <num>, "captures" : <array of strings> }
# 否则返回Null

i、m选项匹配

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        regex_result:{
            $regexFind:{
                input:'Hello World!!!', regex:/he/
            }
        },
        regex_result_i:{
            $regexFind:{
                input:'Hello World!!!',regex:/he/,options:'i'
            }
        },
        regex_result_no_m:{
            $regexFind:{
                input:'Hello \nWorld!', regex:/^World/
            }
        },
        regex_result_m:{
            $regexFind:{
                input:'Hello \nWorld!!!',regex:/^World/,options:'m'
            }
        }
    }
},{$limit:1}
])

x、m选项匹配

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        regex_result_no_x:{
            $regexFind:{
                input:'Hello     World!!!',regex:/He .*/
            }
        },
        regex_result_x:{
            $regexFind:{
                input:'Hello     World!!!',regex:/He             .*/,options:'x'
            }
        },
        regex_result_no_s:{
            $regexFind:{
                input:'Hello  \nWorld!!!',regex:/Hello.*ld/
            }
        },
        regex_result_s:{
            $regexFind:{
                input:'Hello  \nWorld!!!',regex:/Hello.*ld/,options:'s'
            }
        }
    }
},{$limit:1}
])

regexFindAll—正则查找符合条件的所有项

版本要求：4.2+

和regexFind的用法一样，只是regexFindAll会找出所有匹配的项

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        regex_result:{
            $regexFind:{
                input:'Hello World!!!', regex:/o/
            }
        },
        regex_result_all:{
            $regexFindAll:{
                input:'Hello World!!!', regex:/o/
            }
        }
    }
},{$limit:1}
])

regexMatch—判断是否匹配

版本要求：4.2+，和regexFind的用法一样，只是regexMatch匹配成功会返回true，否则返回false

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        regex_result:{
            $regexMatch:{
                input:'Hello World!!!', regex:/he/
            }
        },
        regex_result_i:{
            $regexMatch:{
                input:'Hello World!!!',regex:/he/,options:'i'
            }
        },
    }
},{$limit:1}
])

replaceOne—替换第一次匹配的字符串

版本要求：4.4+

基础语法

xxxxxxxxxx
{ 
    $replaceOne: { 
        input: <expression> 数据源, 
        find: <expression> 查找的字符串, 
        replacement: <expression> 替换的字符串 
    }
}

如将学生姓名中的第一个a替换成AAAAA

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        name:1,
        name_replace:{
            $replaceOne:{
                input:'$name',
                find:'a',
                replacement:'AAAAA'
            }
        }
    }
}
])

replaceAll—替换所有匹配的字符串

版本要求：4.4+，和replaceOne用法一致

如将学生姓名中的e全部替换成EEEEE

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        name:1,
        name_replace:{
            $replaceAll:{
                input:'$name',
                find:'e',
                replacement:'EEEEE'
            }
        }
    }
}
])

split—按照某字符切割字符串

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        split:{
            $split:[
                'Hello World!',
                ' '
            ]
        },
        split2:{
            $split:[
                'Hello World!',
                'o'
            ]
        },
    }
},{$limit:1}
])

strcasecmp—对比字符串大小，不区分大小写

A与B进行比较，若A大于B则返回1，相等则返回0，小于则返回-1

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        strcasecmp_result_equal:{
            $strcasecmp:['abc','ABC']
        },
        strcasecmp_result_great:{
            $strcasecmp:['ABCD','abc']
        },
        strcasecmp_result_less:{
            $strcasecmp:['abc','ABCD']
        },
    }
},{$limit:1}
])

strLenBytes—获取UTF8编码的字节数

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        len_bytes_en:{
            $strLenBytes:'Hello'
        },
        len_bytes_en_space:{
            $strLenBytes:'Hello World!'
        },
        len_bytes_cn:{
            $strLenBytes:'你好哇！'
        },
        len_bytes_jp:{
            $strLenBytes:'爱してる'
        },
        len_bytes_not:{
            $strLenBytes:'cafétéria'
        }
    }
},{$limit:1}
])

strLenCP—返回UTF-8的数量

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        len_bytes_en:{
            $strLenCP:'Hello'
        },
        len_bytes_en_space:{
            $strLenCP:'Hello World!'
        },
        len_bytes_cn:{
            $strLenCP:'你好哇！'
        },
        len_bytes_jp:{
            $strLenCP:'爱してる'
        },
        len_bytes_not:{
            $strLenCP:'cafétéria'
        }
    }
},{$limit:1}
])

substr、substrBytes—截取字符串

mongo3.4+后，两个都是一个意思substr是substrBytes的别名，仅仅演示substr

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        name:1,
        name_sub:{
            $substr:['$name',0,3]
        }
    }
}
])

substrCP—截取字符串

官方例子

不理解

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        sub_str:{
            $substrCP:['abcdEFG',0,2]
        },
        sub_str2:{
            $substrCP:['Hello World!',5,5]
        },
        sub_str3:{
            $substrCP:['!！！!',2,2]
        },
        sub_str4:{
            $substrCP:['cafétéria',4,2]
        },
        sub_str5:{
            $substrCP:["€λG",2,3]
        },
        sub_str6:{
            $substrCP:['你好',1,1]
        }
    }
},{$limit:1}
])

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

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

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        rtrim_str:{
            $rtrim:{input:'Hello World'}
        },
        rtrim_str_ld:{
            $trim:{input:'Hello      Hello World HeHhHe',chars:'He'}
        },
        rtrim_str_space:{
            $trim:{input:'  \r\n   Hello World\t \r\n '}
        },
    }
},{$limit:1}
])

数组相关聚合函数

addToSet—返回唯一值数组

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

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

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

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

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'}
    }
}])

concatArrays—链接数组并返回结果

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

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

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'}
    }
}
])

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个开始查找，第三个停止查找（只查找前三个）

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'
        }
    }
}
])

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}
])

objectToArray—对象转成数组

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        score:1,
        score_arr:{
            $objectToArray:'$score'
        }
    }
},
{$limit:1}
])

push—往数组中添加元素

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

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

range—获取一批有序数组

基础语法，遵循左闭右开原则

xxxxxxxxxx
{ $range: [ 
    <start> 开始, 
    <end> 结束, 
    <non-zero step> 步长、默认1、可选] }

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        range1:{
            $range:[0,5]
        },
        range10:{
            $range:[10,20,2]
        },
    }
},{$limit:1}
])

reduce—遍历数组组成一个值

基础语法

xxxxxxxxxx
{
    $reduce: {
        input: <array>  数据源,
        initialValue: <expression>  初始变量,
        in: <expression> 操作变量,$$value=上次的和，$$this=本次的元素
    }
}

计算从1到10的总积，

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        sum_multiply:{
            $reduce:{
                input:{$range:[1,10]},
                initialValue:1,
                in:{
                    $multiply:['$$this','$$value']
                }
            }
        }
    }
},{$limit:1}
])

reverseArray—将数组前后颠倒

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        arr_ver:{
            $reverseArray:[
                [1,2,3,4]
            ]
        },
        arr_ver_null:{
            $reverseArray:[
                [1,null]
            ]
        },
        arr_ver_arr:{
            $reverseArray:[
                [
                    [1,2,3],
                    [4,5,6]
                ]
            ]
        },
        
    }
},{$limit:1}
])

setDifference—比较两个数组，寻找相较于第一个数组的差集

xxxxxxxxxx
{ 
    $setDifference: [ 
        <expression1>, 
        <expression2> 
        ]
}
# 若1中有，而2中没有，则将该结果返回

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        arr_dif:{
            $setDifference:[
                [1,2,3,4],
                [5,6,7,8]
            ]
        },
        arr_dif_1:{
            $setDifference:[
                [3,4,null,[8]],
                [7,8,3]
            ]
        },
    }
},{$limit:1}
])

setEquals—比较多个数组是否含有相同元素

若多个数组均含有相同元素则返回false，否则返回true，无关顺序

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        arr_equals:{
            $setEquals:[
                [1,2,3,4],
                [5,6,7,8]
            ]
        },
        arr_equals_1:{
            $setEquals:[
                [null,0,null,'1'],
                [null,'1',0,null],
            ]
        },
    }
},{$limit:1}
])

setField—添加、修改、移除字段

基础语法

xxxxxxxxxx
{
  $setField: {
    field: <String> 字段名称,
    input: <Object> 对象,$$this表明当前对象
    value: <Expression> 值，若值为$$REMOVE,则表示删除该字段
  }
}

setIntersection—比较多个数组，并将交集结果返回

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        arr_intersection:{
            $setIntersection:[
                [1,2,3,4],
                [5,6,7,8]
            ]
        },
        arr_intersection_1:{
            $setIntersection:[
                [null,0,null,'1',3,5,8,9],
                [null,null,3,7,9,1]
            ]
        },
        arr_intersection_2:{
            $setIntersection:[
                [3,5,8,9],
                [3,7],
                [3,8,9]
            ]
        },
    }
},{$limit:1}
])

setIsSubset—比较两个数组判断子集

若第一个数组是第二个数组的子集，则将结果为true，否则为false

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        arr_subset:{
            $setIsSubset:[
                [1,2,3,4],
                [5,6,7,8]
            ]
        },
        arr_subset_1:{
            $setIsSubset:[
                [null,0],
                [null,null,3,7,]
            ]
        },
        arr_subset_2:{
            $setIsSubset:[
                [3,8,9],
                [3,8,9]
            ]
        },
    }
},{$limit:1}
])

setUnion—比较多个数组，并将并集结果返回

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        arr_union:{
            $setUnion:[
                [1,2,3,4],
                [5,6,7,8]
            ]
        },
        arr_union_1:{
            $setUnion:[
                [null,0],
                [null,null,3,7,]
            ]
        },
        arr_union_2:{
            $setUnion:[
                [3,8,9],
                [3,8,9]
            ]
        },
    }
},{$limit:1}
])

size—获取数组大小

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        favorites:1,
        favorites_size:{
            $size:'$favorites'
        }
    }
}
])

slice—切割数组

基础语法

xxxxxxxxxx
#从第0位开始获取，获取n个
{ $slice: [ <array>, <n> ] }
​
#从第position位开始获取，获取n个
{ $slice: [ <array>,<position>, <n> ] }

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        favorites:1,
        favorites_size:{
            $slice:['$favorites',2]
        },
        slice_5:{
            $slice:[
                [1,2,3,4,5,6,7,8,9],
                5
            ]
        },
        slice_5_3:{
            $slice:[
                [1,2,3,4,5,6,7,8,9],
                5,
                3
            ]
        }
    }
},{$limit:1}
])

zip—转置数组

基础语法

xxxxxxxxxx
{
    $zip: {
        inputs: [ <array expression1>,  ... ],
        useLongestLength: <boolean> 使用inputs中最长的数组长度、不够则补null、可选,
        defaults:  <array expression>   补位、长度要与inputs的长度一致、可选、指定时useLongestLength要为true
    }
}

xxxxxxxxxx
db.students.aggregate([
{
    $project:{
        zip:{
            $zip:{
                inputs:[['a','b','c'],[1,2,3]]
            }
        },
        zip_long:{
            $zip:{
                inputs:[['a','b','c'],[1]],
                useLongestLength:true
            }
        },
        zip_long_default:{
            $zip:{
                inputs:[['a','b','c'],[1]],
                useLongestLength:true,
                defaults:[2,3]
            }
        }
    }
},{$limit:1}
])

判断相关操作

and—bool运算且

简单例子

xxxxxxxxxx
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}},
        ]
    }
}])

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 } }
   ]
)

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

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

官方例子

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

or—bool或运算

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

xxxxxxxxxx
db.students.aggregate([
{
    $match:{
        $expr:{
            $or:[
                {$gte:['$score.sx',60]},
                {$eq:['$sex','男']},
            ]
        }
    }
},
{
    $project:{
        name:1,
        sex:1,
        sx_score:'$score.sx'
    }
}
])