• MongoDB 常用命令

    原子操作常用命令

    $set

    用来指定一个键并更新键值，若键不存在并创建。

    { $set : { field : value } }

    $unset

    用来删除一个键。

    { $unset : { field : 1} }

    $inc

    $inc可以对文档的某个值为数字型（只能为满足要求的数字）的键进行增减的操作。

    { $inc : { field : value } }

    $push

    用法：

    { $push : { field : value } }

    把value追加到field里面去，field一定要是数组类型才行，如果field不存在，会新增一个数组类型加进去。

    $pushAll

    同$push,只是一次可以追加多个值到一个数组字段内。

    { $pushAll : { field : value_array } }

    $pull

    从数组field内删除一个等于value值。

    { $pull : { field : _value } }

    db.getCollection("eoauthorities").update({},{$pull:{"pushedList":{"ip":{$in:[
    "172.20.28.113"
    ]}}}},{multi:true});

    $addToSet

    增加一个值到数组内，而且只有当这个值不在数组内才增加。

    $pop

    删除数组的第一个或最后一个元素

    { $pop : { field : 1 } }

    $rename

    修改字段名称

    { $rename : { old_field_name : new_field_name } }

    $bit

    位操作，integer类型

    {$bit : { field : {and : 5}}}

    偏移操作符

    > t.find() { "_id" : ObjectId("4b97e62bf1d8c7152c9ccb74"), "title" : "ABC", "comments" : [ { "by" : "joe", "votes" : 3 }, { "by" : "jane", "votes" : 7 } ] } 
    > t.update( {'comments.by':'joe'}, {$inc:{'comments.$.votes':1}}, false, true ) 
    > t.find() { "_id" : ObjectId("4b97e62bf1d8c7152c9ccb74"), "title" : "ABC", "comments" : [ { "by" : "joe", "votes" : 4 }, { "by" : "jane", "votes" : 7 } ] }

    数组查询

    1. db.users.insertMany(
    2.                   [
    3.                      {
    4.                        _id: 1,
    5.                        name: "sue",
    6.                        age: 19,
    7.                        type: 1,
    8.                        status: "P",
    9.                        favorites: { artist: "Picasso", food: "pizza" },
    10.                        finished: [ 17, 3 ],
    11.                        badges: [ "blue", "black" ],
    12.                        points: [
    13.                           { points: 85, bonus: 20 },
    14.                           { points: 85, bonus: 10 }
    15.                        ]
    16.                      },
    17.                      {
    18.                        _id: 2,
    19.                        name: "bob",
    20.                        age: 42,
    21.                        type: 1,
    22.                        status: "A",
    23.                        favorites: { artist: "Miro", food: "meringue" },
    24.                        finished: [ 11, 25 ],
    25.                        badges: [ "green" ],
    26.                        points: [
    27.                           { points: 85, bonus: 20 },
    28.                           { points: 64, bonus: 12 }
    29.                        ]
    30.                      },
    31.                      {
    32.                        _id: 3,
    33.                        name: "ahn",
    34.                        age: 22,
    35.                        type: 2,
    36.                        status: "A",
    37.                        favorites: { artist: "Cassatt", food: "cake" },
    38.                        finished: [ 6 ],
    39.                        badges: [ "blue", "red" ],
    40.                        points: [
    41.                           { points: 81, bonus: 8 },
    42.                           { points: 55, bonus: 20 }
    43.                        ]
    44.                      },
    45.                      {
    46.                        _id: 4,
    47.                        name: "xi",
    48.                        age: 34,         
    49.                        type: 2,         
    50.                        status: "D",
    51.                        favorites: { artist: "Chagall", food: "chocolate" },
    52.                        finished: [ 5, 11 ],
    53.                        badges: [ "red", "black" ],
    54.                        points: [
    55.                           { points: 53, bonus: 15 },
    56.                           { points: 51, bonus: 15 }
    57.                        ]
    58.                      },
    59.                      {
    60.                        _id: 5,
    61.                        name: "xyz",
    62.                        age: 23,
    63.                        type: 2,
    64.                        status: "D",
    65.                        favorites: { artist: "Noguchi", food: "nougat" },
    66.                        finished: [ 14, 6 ],
    67.                        badges: [ "orange" ],
    68.                        points: [
    69.                           { points: 71, bonus: 20 }
    70.                        ]
    71.                      },
    72.                      {
    73.                        _id: 6,
    74.                        name: "abc",
    75.                        age: 43,
    76.                        type: 1,
    77.                        status: "A",
    78.                        favorites: { food: "pizza", artist: "Picasso" },
    79.                        finished: [ 18, 12 ],
    80.                        badges: [ "black", "blue" ],
    81.                        points: [
    82.                           { points: 78, bonus: 8 },
    83.                           { points: 57, bonus: 7 }
    84.                        ]
    85.                      }
    86.                   ]
    87.                 )

    1、数组元素模糊匹配

    1. //如下示例，数组字段badges每个包含该元素black的文档都将被返回
    2.         > db.users.find({badges:"black"},{"_id":1,badges:1})
    3.         { "_id" : 1, "badges" : [ "blue", "black" ] }
    4.         { "_id" : 4, "badges" : [ "red", "black" ] }
    5.         { "_id" : 6, "badges" : [ "black", "blue" ] }

    2、数组元素精确(全)匹配

    1. //如下示例，数组字段badges的值为["black","blue"]的文档才能被返回(数组元素值和元素顺序全匹配)
    2.         > db.users.find({badges:["black","blue"]},{"_id":1,badges:1})
    3.         { "_id" : 6, "badges" : [ "black", "blue" ] }

    3、通过数组下标返回指定的文档

    1. 数组的下标从0开始，指定下标值则返回对应的文档
    2.         //如下示例，返回数组badges中第一个元素值为black的文档
    3.         > db.users.find({"badges.1":"black"},{"_id":1,badges:1})
    4.         { "_id" : 1, "badges" : [ "blue", "black" ] }
    5.         { "_id" : 4, "badges" : [ "red", "black" ] }

    4、范围条件任意元素匹配查询

    1. //查询数组finished的元素值既大于15，又小于20的文档
    2.         > db.users.find( { finished: { $gt: 15, $lt: 20}},{"_id":1,finished:1})
    3.         { "_id" : 1, "finished" : [ 17, 3 ] }
    4.         { "_id" : 2, "finished" : [ 11, 25 ] }
    5.         { "_id" : 6, "finished" : [ 18, 12 ] }
    6.  
    7.         //下面插入一个新的文档，仅包含单个数组元素
    8.         > db.users.insert({"_id":7,finished:[19]})
    9.         WriteResult({ "nInserted" : 1 })
    10.  
    11.         //再次查询，新增的文档也被返回
    12.         > db.users.find( { finished: { $gt: 15, $lt: 20}},{"_id":1,finished:1})
    13.         { "_id" : 1, "finished" : [ 17, 3 ] }
    14.         { "_id" : 2, "finished" : [ 11, 25 ] }
    15.         { "_id" : 6, "finished" : [ 18, 12 ] }
    16.         { "_id" : 7, "finished" : [ 19 ] }

    5、数组内嵌文档查询

    1. //查询数组points元素1内嵌文档键points的值小于等于55的文档(精确匹配)
    2.         > db.users.find( { 'points.0.points': { $lte: 55}},{"_id":1,points:1})
    3.         { "_id" : 4, "points" : [ { "points" : 53, "bonus" : 15 }, { "points" : 51, "bonus" : 15 } ] }
    4.  
    5.     //查询数组points内嵌文档键points的值小于等于55的文档，此处通过.成员的方式实现
    6.         > db.users.find( { 'points.points': { $lte: 55}},{"_id":1,points:1})
    7.         { "_id" : 3, "points" : [ { "points" : 81, "bonus" : 8 }, { "points" : 55, "bonus" : 20 } ] }
    8.         { "_id" : 4, "points" : [ { "points" : 53, "bonus" : 15 }, { "points" : 51, "bonus" : 15 } ] }

    6、数组元素操作符$elemMatch

    1. 作用：数组值中至少一个元素满足所有指定的匹配条件
    2.         语法：  { <field>: { $elemMatch: { <query1>, <query2>, ... } } }
    3.         说明：  如果查询为单值查询条件，即只有<query1>，则无需指定$elemMatch
    4.  
    5.         //如下示例,为无需指定$elemMatch情形
    6.         //查询数组内嵌文档字段points.points的值为85的文档
    7.         > db.users.find( { "points.points": 85},{"_id":1,points:1})
    8.         { "_id" : 1, "points" : [ { "points" : 85, "bonus" : 20 }, { "points" : 85, "bonus" : 10 } ] }
    9.         { "_id" : 2, "points" : [ { "points" : 85, "bonus" : 20 }, { "points" : 64, "bonus" : 12 } ] }
    10.  
    11.         > db.users.find( { points:{ $elemMatch:{points:85}}},{"_id":1,points:1})
    12.         { "_id" : 1, "points" : [ { "points" : 85, "bonus" : 20 }, { "points" : 85, "bonus" : 10 } ] }
    13.         { "_id" : 2, "points" : [ { "points" : 85, "bonus" : 20 }, { "points" : 64, "bonus" : 12 } ] }
    14.  
    15.         //单数组查询($elemMatch示例)
    16.         > db.scores.insertMany(
    17.         ... [{ _id: 1, results: [ 82, 85, 88 ] }, //Author : Leshami
    18.         ... { _id: 2, results: [ 75, 88, 89 ] }]) //Blog   : http://blog.csdn.net/leshami
    19.         { "acknowledged" : true, "insertedIds" : [ 1, 2 ] }
    20.         > db.scores.find({ results: { $elemMatch: { $gte: 80, $lt: 85 } } })
    21.         { "_id" : 1, "results" : [ 82, 85, 88 ] }
    22.  
    23.         //数组内嵌文档查询示例($elemMatch示例)
    24.         //查询数组内嵌文档字段points.points的值大于等于70，并且bonus的值20的文档(要求2个条件都必须满足)
    25.         //也就是说数组points的至少需要一个元素同时满足以上2个条件，这样的结果文档才会返回
    26.         //下面的查询数组值{ "points" : 55, "bonus" : 20 }满足条件
    27.         > db.users.find( { points: { $elemMatch: { points: { $lte: 70 }, bonus: 20}}},{"_id":1,points:1})
    28.         { "_id" : 3, "points" : [ { "points" : 81, "bonus" : 8 }, { "points" : 55, "bonus" : 20 } ] }

    7、数组元素操作符$all

    1. 作用：数组值中满足所有指定的匹配条件，不考虑多出的元素以及元素顺序问题
    2.         语法：{ <field>: { $all: [ <value1> , <value2> ... ] } }
    3.  
    4.         > db.users.find({badges:{$all:["black","blue"]}},{"_id":1,badges:1})
    5.         { "_id" : 1, "badges" : [ "blue", "black" ] }  //此处查询的结果不考虑元素的顺序
    6.         { "_id" : 6, "badges" : [ "black", "blue" ] }  //只要包含这2个元素的集合都被返回
    7.  
    8.         等价的操作方式
    9.         > db.users.find({$and:[{badges:"blue"},{badges:"black"}]},{"_id":1,badges:1})
    10.         { "_id" : 1, "badges" : [ "blue", "black" ] }
    11.         { "_id" : 6, "badges" : [ "black", "blue" ] }

    8、数组元素操作符$size

    1. 作用：返回元素个数总值等于指定值的文档
    2.         语法：db.collection.find( { field: { $size: 2 } } );
    3.         说明：$size不支持指定范围，而是一个具体的值。此外针对$size，没有相关可用的索引来提高性能
    4.  
    5.         //查询数组badges包含1个元素的文档       
    6.         > db.users.find({badges:{$size:1}},{"_id":1,badges:1})
    7.         { "_id" : 2, "badges" : [ "green" ] }
    8.         { "_id" : 5, "badges" : [ "orange" ] }
    9.  
    10.         //查询数组badges包含2个元素的文档
    11.         > db.users.find({badges:{$size:2}},{"_id":1,badges:1})
    12.         { "_id" : 1, "badges" : [ "blue", "black" ] }
    13.         { "_id" : 3, "badges" : [ "blue", "red" ] }
    14.         { "_id" : 4, "badges" : [ "red", "black" ] }
    15.         { "_id" : 6, "badges" : [ "black", "blue" ] }

    9、数组元素操作符$slice

    1. 作用：用于返回指定位置的数组元素值的子集(是数值元素值得一部分，不是所有的数组元素值)
    2.         示例：db.collection.find( { field: value }, { array: {$slice: count } } );        
    3.  
    4.         //创建演示文档
    5.         > db.blog.insert(
    6.         ... {_id:1,title:"mongodb unique index",
    7.         ... comment: [
    8.         ... {"name" : "joe","content" : "nice post."},
    9.         ... {"name" : "bob","content" : "good post."},
    10.         ... {"name" : "john","content" : "greatly."}]}
    11.         ... )
    12.         WriteResult({ "nInserted" : 1 })
    13.  
    14.         //通过$slice返回集合中comment数组第一条评论
    15.         > db.blog.find({},{comment:{$slice:1}}).pretty()
    16.         {
    17.                 "_id" : 1,
    18.                 "title" : "mongodb unique index",
    19.                 "comment" : [
    20.                         {
    21.                                 "name" : "joe",
    22.                                 "content" : "nice post."
    23.                         }
    24.                 ]
    25.         }
    26.  
    27.         //通过$slice返回集合中comment数组最后一条评论
    28.         > db.blog.find({},{comment:{$slice:-1}}).pretty()
    29.         {
    30.                 "_id" : 1,
    31.                 "title" : "mongodb unique index",
    32.                 "comment" : [
    33.                         {
    34.                                 "name" : "john",
    35.                                 "content" : "greatly."
    36.                         }
    37.                 ]
    38.         }
    39.  
    40.         //通过$slice返回集合中comment数组特定的评论(可以理解为分页)
    41.         //如下查询，返回的是第2-3条评论，第一条被跳过
    42.         > db.blog.find({},{comment:{$slice:[1,3]}}).pretty()
    43.         {
    44.                 "_id" : 1,
    45.                 "title" : "mongodb unique index",
    46.                 "comment" : [
    47.                         {
    48.                                 "name" : "bob",
    49.                                 "content" : "good post."
    50.                         },
    51.                         {
    52.                                 "name" : "john",
    53.                                 "content" : "greatly."
    54.                         }
    55.                 ]
    56.         }

    10、$占位符，返回数组中第一个匹配的数组元素值(子集)

    1. 使用样式：
    2.                 db.collection.find( { <array>: <value> ... },
    3.                                     { ".$": 1 } )
    4.                 db.collection.find( { <array.field>: <value> ...},
    5.                                     { ".$": 1 } )
    6.  
    7.         使用示例
    8.         > db.students.insertMany([
    9.                 { "_id" : 1, "semester" : 1, "grades" : [ 70, 87, 90 ] },
    10.                 { "_id" : 2, "semester" : 1, "grades" : [ 90, 88, 92 ] },
    11.                 { "_id" : 3, "semester" : 1, "grades" : [ 85, 100, 90 ] },
    12.                 { "_id" : 4, "semester" : 2, "grades" : [ 79, 85, 80 ] },
    13.                 { "_id" : 5, "semester" : 2, "grades" : [ 88, 88, 92 ] },
    14.                 { "_id" : 6, "semester" : 2, "grades" : [ 95, 90, 96 ] }])                                          
    15.  
    16.         //通过下面的查询可知，仅仅只有第一个大于等于85的元素值被返回
    17.         //也就是说$占位符返回的是数组的第一个匹配的值，是数组的子集
    18.         > db.students.find( { semester: 1, grades: { $gte: 85 } },
    19.         ... { "grades.$": 1 } )
    20.         { "_id" : 1, "grades" : [ 87 ] }
    21.         { "_id" : 2, "grades" : [ 90 ] }
    22.         { "_id" : 3, "grades" : [ 85 ] }
    23.  
    24.  
    25.         > db.students.drop()
    26.  
    27.         //使用新的示例数据
    28.         > db.students.insertMany([
    29.                 { "_id" : 7, semester: 3, "grades" : [ { grade: 80, mean: 75, std: 8 },
    30.                                                { grade: 85, mean: 90, std: 5 },
    31.                                                { grade: 90, mean: 85, std: 3 } ] },
    32.             { "_id" : 8, semester: 3, "grades" : [ { grade: 92, mean: 88, std: 8 },
    33.                                                { grade: 78, mean: 90, std: 5 },
    34.                                                { grade: 88, mean: 85, std: 3 } ] }])
    35.  
    36.         //下面的查询中，数组的元素为内嵌文档，同样如此，数组元素第一个匹配的元素值被返回
    37.         > db.students.find(
    38.         ...    { "grades.mean": { $gt: 70 } },
    39.         ...    { "grades.$": 1 }
    40.         ... )
    41.         { "_id" : 7, "grades" : [ { "grade" : 80, "mean" : 75, "std" : 8 } ] }
    42.         { "_id" : 8, "grades" : [ { "grade" : 92, "mean" : 88, "std" : 8 } ] }

    更新数组中的所有元素

    操作符：$[]

    1. { "_id" : 1, "grades" : [ 85, 82, 80 ] }
    2. { "_id" : 2, "grades" : [ 88, 90, 92 ] }
    3. { "_id" : 3, "grades" : [ 85, 100, 90 ] }
    4.  
    5. db.students.update(
    6.    { },
    7.    { $inc: { "grades.$[]": 10 } },//给名为grade的数组中所有元素加10
    8.    { multi: true }//更新所有doc
    9. )

    更新内嵌文档

    1. {
    2.    "_id" : 1,
    3.    "grades" : [
    4.       { "grade" : 80, "mean" : 75, "std" : 8 },
    5.       { "grade" : 85, "mean" : 90, "std" : 6 },
    6.       { "grade" : 85, "mean" : 85, "std" : 8 }
    7.    ]
    8. }
    9. {
    10.    "_id" : 2,
    11.    "grades" : [
    12.       { "grade" : 90, "mean" : 75, "std" : 8 },
    13.       { "grade" : 87, "mean" : 90, "std" : 5 },
    14.       { "grade" : 85, "mean" : 85, "std" : 6 }
    15.    ]
    16. }
    17.  
    18. db.students2.update(
    19.    { },
    20.    { $inc: { "grades.$[].std" : -2 } },  //更新grade数组中 每个属性位std的值
    21.    { multi: true }//更新所有记录
    22. )

    a、数组查询有精确和模糊之分，精确匹配需要指定数据元素的全部值

    b、数组查询可以通过下标的方式进行查询

    c、数组内嵌套文档可以通过.成员的方式进行查询

    d、数组至少一个元素满足所有指定的匹配条件可以使用$elemMatch

    e、数组查询中返回元素的子集可以通过$slice以及占位符来实现

    f、all满足所有指定的匹配条件，不考虑多出的元素以及元素顺序问题 

    $数组更新

    定位符$的确定数组中一个要被更新的元素的位置，而不用具体指定该元素在数组中的位置。

    1. db.students.insert([
    2.    { "_id" : 1, "grades" : [ 85, 80, 80 ] },
    3.    { "_id" : 2, "grades" : [ 88, 90, 92 ] },
    4.    { "_id" : 3, "grades" : [ 85, 100, 90 ] }
    5. ])
    6.  
    7. #将grades数组中第一个值为80更新为82，如果你不知道第一个值的具体位置，就可以像下面这样写：
    8. db.students.updateOne(
    9.    { _id: 1, grades: 80 },
    10.    { $set: { "grades.$" : 82 } }
    11. )
    12.  
    13. #更新数组中的文档
    14. db.collection.update(
    15.    { <query selector> },
    16.    { <update operator>: { "array.$.field" : value } }
    17. )
    18. #样例：
    19. {
    20.   _id: 4,
    21.   grades: [
    22.      { grade: 80, mean: 75, std: 8 },
    23.      { grade: 85, mean: 90, std: 5 },
    24.      { grade: 85, mean: 85, std: 8 }
    25.   ]
    26. }
    27. #使用$定位符去更新grades数组中文档中字段std的值，被更新的文档是第一个匹配grade值为85的文档
    28. db.students.updateOne(
    29.    { _id: 4, "grades.grade": 85 },
    30.    { $set: { "grades.$.std" : 6 } }
    31. )

    条件更新

    1. db.students3.insert([
    2.    { "_id" : 1,
    3.       "grades" : [
    4.         { type: "quiz", questions: [ 10, 8, 5 ] },
    5.         { type: "quiz", questions: [ 8, 9, 6 ] },
    6.         { type: "hw", questions: [ 5, 4, 3 ] },
    7.         { type: "exam", questions: [ 25, 10, 23, 0 ] },
    8.       ]
    9.    }
    10. ])
    11.  
    12. #条件是给grades数组中questions里分数>=8的+2
    13. db.students3.update(
    14.    {},
    15.    //这里score是过滤规则的名字
    16.    { $inc: { "grades.$[].questions.$[score]": 2 } },
    17.    //这里定义了score过滤规则
    18.    { arrayFilters: [  { "score": { $gte: 8 } } ], multi: true}
    19. )

    Mongodb--操作符

    一、比较操作符

    　用于比较两个表达式并从mongoDB集合中获取数据，常用操作符如下：

    操作符格式示例类似于sql语句备注
    （>）大于 - $gt{:{$gt:}} db.big.find({"age":{$gt:22}}) where age > 22查询age大于22的数据
    （<）小于 - $lt{:{$lt:}} db.big.find({"age":{$lt:20}}) where age < 20
    （>=）大于等于 - $gte{:{$gte:}} db.big.find({"age":{$gte:22}}) where age >= 22
    （<=）小于等于 - $lte{:{$lte:}} db.big.find({"age":{$lte:22}}) where age <= 22
    （=） 等于 - $eq{:} db.big.find({"name":"jun"}) where name = 'jun'
     　　　　　　$in{ field: { $in: [, , ... ] } }

     db.big.find({"age":{$type:"array"}})

     db.big.find({"age":{$in:[25,22]}})

    		匹配字段值等于指定数组中的任何值(字段值为数组类型时，数组中至少有一个元素在指定数组中)
    （!=）不等于 - $ne{:{$ne:}} db.big.find({"age":{$ne:22}}) where age != 22
    　　　　　　 $nin{ field: { $nin: [ , ... ]} }

     db.big.find({"name":{$nin:["jun","wang"]}})

     db.big.find({"age":{$nin:[25,22]}})

    		字段值不在指定数组或者不存在(字段值为数组类型时，数组中没有一个元素与指定数组中元素相等)

    二、逻辑操作符

    操作符格式示例备注
    $or{ $or: [ { }, { }, ... , { } ] }db.big.find({$or:[{"name":"jun"},{"age":25}]})文档至少满足其中的一个表达式
    $and{ $and: [ { }, { } , ... , { } ] }db.big.find({"name":"jun","age":25})文档满足所有的表达式
    $not{ field: { $not: { } } }db.big.find({"age":{$not:{$gt:22}}})字段值不匹配表达式或者字段值不存在
    $nor{ $nor: [ { }, { }, ... { } ] }

    db.big.find({$nor:[{"age":18},{"name":"jun"}]})

    db.big.find({$nor:[{"name":"jun"},{"age":{$lt:20}},{"sex":"x"}]})

    		字段值不匹配所有的表达式的文档，包括那些不包含这些字段的文档

     三、元素操作符

    　3.1 $exists

    1. 语法： { field: { $exists: <boolean> } }
    2.  
    3. 1.当boolean为true,$exists匹配包含字段的文档，包括字段值为null的文档。
    4. 2.当boolean为false,$exists返回不包含对应字段的文档。
    5.  
    6. 示例：
    7. db.big.find({"name":{$exists:true}})

    　3.2 $type

    匹配字段值为指定数据类型的文档
{ field: { $type:  |  } }
    类型数字备注
    Double1
    String2
    Object3
    Array4
    Binary data5
    Object id7
    Boolean8
    Date9
    Null10
    Regular Expression11
    JavaScript13
    Symbol14
    JavaScript (with scope)15
    32-bit integer16
    Timestamp17
    64-bit integer18
    Min key255Query with -1.
    Max key127
    示例：
db.big.find({"name":{$type:2}})
db.big.find({"name":{$type:"string"}})

    四、评估操作符

     　4.1 $mod

    1. 匹配字段值被除有指定的余数的文档
    2. 语法：{ field: { $mod: [ divisor(除数), remainder(余数) ] } }
    3. 示例：db.big.find({"age":{$mod:[5,0]}})

    　4.2 $regex

    1. 语法：
    2. { <field>: { $regex: /pattern/, $options: '' } }
    3. { <field>: { $regex: 'pattern', $options: '' } }
    4. { <field>: { $regex: /pattern/<options> } }
    5.  
    6. 参数：
    7. i:忽略大小写
    8. m:多行匹配
    9. x:忽略空格
    10. s:点号可以匹配换行符
    11.  
    12. 示例：
    13. db.big.find({"name":{$regex:/^jun/i}})
    14. db.big.find({"name":{$regex:/^jun/,$options:'i'}})

    　4.3 $text

    1. 　　MongoDB支持对文本内容执行文本搜索操作，其提供了索引text index和查询操作$text来完成文本搜索功能。
    2.  
    3. 　　只有拥有text index的collection才支持全文检索
    4.  
    5. 　　每个collection只能拥有一个text index
    6.  
    7. 　　Text index可以包含任何的string类型、string数组类型的字段
    8.  
    9. 　　Text index可以包含多个字段
    10.  
    11. 　　使用createIndex或ensureIndex函数来创建索引，详见：https://www.cnblogs.com/Xinenhui/p/15871849.html

    　4.4 $where

    　　$where操作符功能强大且灵活，它可以将JavaScript表达式的字符串或 JavaScript函数作为查询语句的一部分。在JavaScript表达式和函数中，可以 使用this或obj来引用当前操作的文档。 JavaScript表达式或函数返回值为true时，才会返回当前的文档。

    　　查询时，$where操作符不能使用索引，每个文档需要从BSON对象转换成 JavaSript对象后，才可以通过$where表达式来运行。因此，它比常规查询要 慢很多，一般情况下，要避免使用$where查询。

    五、数组操作符

    操作符格式示例备注
    $all{ : { $all: [ , ... ] } }db.big.find({"name":{$all:["wang","zhang","chen"]}})字段值是包含所有指定元素的数组的文档
    $elemMatch{ : { $elemMatch: { , , ... } } }db.big.find({"name":{$elemMatch:{"wang":"jun","age":2}}})数组字段至少一个元素满足所有指定查询条件的文档
    $size{ field: { $size: 2 } }匹配数组字段元素个数等于指定数量的文档

    foreach 函数

    1. //在函数中依然可以调用
    2. var param = db.sm_pm_paramconfig.find({
    3.         paramGroup: "BUSINESSUNIT"
    4.     });
    5.  
    6. //对信息表进行遍历操作
    7. db.userinfo.find().forEach(function(item) {
    8.     var arr = item.address.split("_");
    9.     //获取部门名称
    10.     var deptName = "";
    11.     var num = -1;
    12.     for (var i = 0; i < arr.length; i++) {
    13.         if ("****" == arr[i]) {
    14.             num = i;
    15.             break;
    16.         }
    17.     }
    18.     if (num >= 0) {
    19.         deptName = arr[num + 1];
    20.     } else {
    21.         deptName = "****";
    22.     }
    23.  
    24.     var temp=db.Goods.findOne({"goodsCode":{"$regex":"^"+tempGoodCode+".+"}});
    25.     if(temp){
    26.  
    27.     }
    28.  
    29.     //插入ID
    30.     //注意：param获取的对象要toarray一下才能遍历。
    31.     var config = param.toArray();
    32.     for (var j = 0, len = config.length; j < len; j++) {
    33.         if (deptName == config[j].paramValue) {
    34.             //插入新字段
    35.             db.userinfo.update({
    36.                 "_id": item._id
    37.             }, {
    38.                 $set: {
    39.                     "businessUnitId": config[j]._id
    40.                 }
    41.             });
    42.             break;
    43.         }
    44.     }
    45. })

    参考文档：

    Query and Projection Operators — MongoDB Manual

  • 相关阅读:
    Lumiprobe 活性染料丨杂染料：BDP FL 神经酰胺
    python - yield详解
    基于单片机设计的电子指南针(LSM303DLH模块(三轴磁场 + 三轴加速度)
    算法 数据结构 递归插入排序 java插入排序 递归求解插入排序算法 如何用递归写插入排序 插入排序动图 插入排序优化 数据结构（十）
    maven Could not resolve dependencies for project xxx:jar 错误原因及解决方案
    改进的人工鱼群算法求解TSP问题的研究（Matlab代码实现）
    TypeScript 学习笔记
    软件设计师中级
    解密 Shell 重定向：＞、＞1、2＞、＆＞、＞&、2＞&1、1＞&2 、/dev/null、＞＞、＞＞2、&＞＞
    优思学院｜统计过程控制SPC的两大作用
  • 原文地址：https://blog.csdn.net/huaishu/article/details/128130333