1. 1.基本查询
    2.     ①方法find():查询
    3.         db.集合名称.find({条件文档})
    4.     ②方法findOne():查询，只返回第一个
    5.         db.集合名称.findOne({条件文档})
    6.     ③方法pretty():将结果格式化
    7.         db.集合名称.find({条件文档}).pretty()
    8. 2.比较运算符
    9.     # 等于，默认是等于判断，没有运算符
    10.     # 小于，$lt   less-than
    11.     # 小于或等于，$lte   less-than,equal
    12.     # 大于，$gt    greater-than
    13.     # 小于或等于，$gte    greater-than,equal
    14.     # 不等于，$ne    not equal  
    15.         db.collection2.find({name:'郭靖'})
    16.         db.collection2.find({age:{$gte:18}})
    17. 3.逻辑运算符
    18.     ①逻辑与
    19.         # 默认是逻辑与的关系
    20.         # 例：查询年龄大于或等于18，并且性别为true的学生
    21.             db.collection2.find({age:{$gte:18}, gender:true})
    22.     ②逻辑或
    23.         # 使用$or,值为数组，数组中每个元素为json
    24.         # 例：查询年龄大于18，或性别为false的学生
    25.             db.collection2.find({$or:[{age:{$gt:18}},{gender:false}]})
    26.         注意点：find() >> 或条件下的{} >> $or[ ] >>
    27.         >>  {条件a},{条件b} >> {域:{ 逻辑符判断} }
    28.     ③或、与共用
    29.         # 例：查询年龄大于18或姓名是郭靖，并且性别为男生
    30.             db.collection2.find( {$or:[ {age:{$gt:18} },{name:'郭靖'} ],gender:true} )
    31. 4.范围运算符
    32.     # $in|$nin
    33.     # 例：查询年龄为18,28的学生
    34.         db.collection2.find( {age:{$in:[18, 28] } } )
    35.     # 这里要注意了，最大与最小都需要表中含有这几个数
    36. 5.支持正则表达式
    37.     # 使用 // 或 $regex 编写正则表达式
    38.     # 例：db.collection2.find( {name:/^黄/} )
    39.         db.collection2.find( {name:{$regex:'^黄'} } )
    40. 6.自定义查询
    41.     # 使用$where后面写一个函数，返回满足条件的数据
    42.     # 例：查询大于30岁的学生
    43.         db.collection2.find(
    44.         {
    45.         $where: function(){
    46.         return this.age > 18
    47.         }})
    48. 7.Limit和Skip
    49.     ①方法limit():读取指定数量的文档
    50.         # db.集合名称.find().limit(NUMBER)
    51.         db.collection2.find().limit(2)
    52.         # 附：如果指定参数则显示集合中的所有文档
    53.     ②方法skip()：用于跳过指定数量的文档
    54.         # db.集合名称.find().skip(NUMBER)
    55.         db.stu.find().skip(2)
    56.         # 附：参数NUMBER表示跳过的记录条数，默认为0
    57.     ③limit()与skip()一起使用
    58.         # 不分先后顺序；跳过指定数量文档，再读取指定数量的文档
    59.         # 查询数据
    60.         db.collection1.find().limit(4).skip(5)
    61.         db.collection1.find().skip(5).limit(4)
    62. 8.投影
    63.     --选择字段显示数据
    64.         # ①db.集合名称.find({},{ 字段名称:1, ...})
    65.         db.collection2.find({},{name:1, gender:1})
    66.         # '1':表示显示字段，不设置表示不显示
    67.         # ②特殊：对于_id列默认是显示的，
    68.         # 如果不显示需要明确设置为0
    69.         db.collection2.find({},{_id:0,name:1,gender:1})
    70. 9.排序
    71.     --对结果集进行排序
    72.         参数1为升序排列
    73.         参数-1位降序排列
    74.     # db.集合名称.find().sort({字段：1....})
    75.     # --根据性别降序，再根据年龄升序
    76.         db.collection2.find().sort({gender:-1,age:1})
    77. 10.统计个数
    78.     ①方法count()：用于统计结果集中文档条数
    79.         1.db.集合名称.find({条件}).count()
    80.         db.collection2.find({gender:true}).count()
    81.         # --统计男生人数
    83.         2.db.集合名称.count({条件})
    84.         db.collection2.count({age:{$gt:20}, gender:true})
    85.         # --统计年龄大于20的男生人数
    86. 11.消除重复
    87.     ①方法distinct()：对字段数据进行去重，提取
    88.     --db.集合名称.distinct('去重字段',{条件})
    89.     db.collection2.distinct('hometown',{age:{$gt:18}})
    90.     # 查询年龄大于18岁的学生，来自哪些省份
    92. # 4.聚合查询
    93. 1.基本语法
    94.     --语法
    95.     db.集合名称.aggregate( {管道: {表达式} } )
    96.     附：
    97.         1.管道：在Unix和Linux中一般用于将当前命令的
    98.         输出结果作为下一个命令的输入
    99.         2.表达式：处理输入文档并输出
    100. 2.常用表达式
    101.     $sum: 计算综合，$sum:1 表示以一倍计数
    102.     $avg: 计算平均值
    103.     $min: 获取最小值
    104.     $max: 获取最大值
    105.     $push: 在结果文档中插入值到第一个文档数据
    106.     $first: 根据资源文档的排序获取第一个文档数据
    107.     $last: 根据资源文档的排序获取最后一个文档数据
    108. 3.常用管道
    109.     ①$group
    110.         --将集合中的文档分组，可用于统计结果
    111.         --_id表示分组的依据，使用某个字段的格式为'$字段'
    112.             # 统计男生、女生的总人数
    113.             db.stu.aggregate(
    114.                 {$group:
    115.                     {
    116.                         _id:'$gender',
    117.                         counter:{$sum:1}
    118.                     }
    119.                 }
    120.             )
    121.         --透视数据
    122.             # 统计学生性别及学生姓名
    123.             db.stu.aggregate(
    124.                 {$group:
    125.                     {
    126.                         _id:'$gender',
    127.                         name:{$push:'$name'}
    128.                     }
    129.                 }
    130.             )
    131.         --使用$$ROOT可以将文档内容加入到结果集的数组中
    132.             db.stu.aggregate(
    133.                 {$group:
    134.                     {
    135.                         _id:'$gender',
    136.                         name:{$push:'$$ROOT'}
    137.                     }
    138.                 }
    139.             )
    140.     ②$match
    141.         --修改输入文档的结构，如重命名、增加、删除字段、创建计算结果
    142.         --用于过滤数据，只输出符合条件的文档
    143.         --使用MongoDB的标准查询操作
    144.         # 查询年龄大于20的学生
    145.         db.stu.aggregate(
    146.             {$match:{age:{$gt:20}}}
    147.         )
    149.         # 查询年龄大于20的男生、女生人数
    150.         db.stu.aggregate(
    151.             {$match:{age:{$gt:20}}},
    152.             {$group:{_id:'$gender',counter:{$sum:1}}}
    153.         )
    154.     ③$project
    155.         --修改输入文档的结构，
    156.            如重命名、增加、删除字段、创建计算结果
    157.         # 查询学生的姓名、年龄
    158.         db.stu.aggregate(
    159.             {$project:{_id:0,name:1,age:1}}
    160.         )
    162.         # 查询男生、女生人数，输出人数
    163.         db.stu.aggregate(
    164.             {$group:{_id:'$gender',counter:{$sum:1}}},
    165.             {$project:{_id:0,counter:1}}
    166.         )
    167.     ④$sort
    168.         --将输入文档排序后输出
    169.         # 查询学生信息，按年龄升序
    170.         b.stu.aggregate({$sort:{age:1}})
    172.         # 查询男生、女生人数，按人数降序
    173.         db.stu.aggregate(
    174.             {$group:{_id:'$gender',counter:{$sum:1}}},
    175.             {$sort:{counter:-1}}
    176.         )
    177.     ⑤$limit和$skip
    178.         --$limit
    179.         # 限制聚合管道返回的文档数
    180.         # 查询2条学生信息
    181.             db.stu.aggregate({$limit:2})
    183.         --$skip
    184.         # 跳过指定数量的文档，并返回余下的文档
    185.         # 查询从第3条开始的学生信息
    186.             db.stu.aggregate({$skip:2})
    188.         # 统计男生，女生人数，按人数升序，取第2条数据
    189.             db.stu.aggregate(
    190.                 {$group:{_id:'$gender', counter:{$sum:1}}}
    191.                 {$sort:{counter:1}}
    192.                 {$skip:1}
    193.                 {$limit:1}
    194.             )
    195.     ⑥$unwind字段拆分查询
    196.         --语法
    197.         --文档中一个数组字段含有多个值
    198.         --根据字段下的值拆分多条
    199.         --每条包含数组中的一个值
    201.         --db.集合名称.aggregate({$unwind:'$字段名称'})
    202.             # $unwind聚合方法下含有两个属性：
    203.                 path:'$字段名称'
    204.                 preserveNullAndEmptyArrays:<布尔值>
    205.             # 不填写属性，默认表示<布尔值>为false
    206.             # 且不用标记属性名
    207.         --构造数据
    208.             db.t3.insert([
    209.             { "_id" : 1, "item" : "a", "size": [ "S", "M", "L"] },
    210.             { "_id" : 2, "item" : "b", "size" : [ ] },
    211.             { "_id" : 3, "item" : "c", "size": "M" },
    212.             { "_id" : 4, "item" : "d" },
    213.             { "_id" : 5, "item" : "e", "size" : null }
    214.             ])
    215.         --查看查询结果，显示对空数组，无字段，null的文档
    216.             db.t3.aggregate( { $unwind:{ path:'$size', preserveNullAndEmptArrays:true}})
    218.         --查看查询结果，不显示空数组，无字段，null的文档
    219.             db.t3.aggregate({$unwind: '$size'})  相当于：
    220.             db.t3.aggregate({$unwind:{path:'$size', preserveNullAndEmptyArrays:false}})