原子操作常用命令

$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 } }

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

数组查询

db.users.insertMany([{_id: 1,name: "sue",age: 19,type: 1,status: "P",favorites: { artist: "Picasso", food: "pizza" },finished: [ 17, 3 ],badges: [ "blue", "black" ],points: [{ points: 85, bonus: 20 },{ points: 85, bonus: 10 }]},{_id: 2,name: "bob",age: 42,type: 1,status: "A",favorites: { artist: "Miro", food: "meringue" },finished: [ 11, 25 ],badges: [ "green" ],points: [{ points: 85, bonus: 20 },{ points: 64, bonus: 12 }]},{_id: 3,name: "ahn",age: 22,type: 2,status: "A",favorites: { artist: "Cassatt", food: "cake" },finished: [ 6 ],badges: [ "blue", "red" ],points: [{ points: 81, bonus: 8 },{ points: 55, bonus: 20 }]},{_id: 4,name: "xi",age: 34,         type: 2,         status: "D",favorites: { artist: "Chagall", food: "chocolate" },finished: [ 5, 11 ],badges: [ "red", "black" ],points: [{ points: 53, bonus: 15 },{ points: 51, bonus: 15 }]},{_id: 5,name: "xyz",age: 23,type: 2,status: "D",favorites: { artist: "Noguchi", food: "nougat" },finished: [ 14, 6 ],badges: [ "orange" ],points: [{ points: 71, bonus: 20 }]},{_id: 6,name: "abc",age: 43,type: 1,status: "A",favorites: { food: "pizza", artist: "Picasso" },finished: [ 18, 12 ],badges: [ "black", "blue" ],points: [{ points: 78, bonus: 8 },{ points: 57, bonus: 7 }]}])

1、数组元素模糊匹配

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

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

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

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

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

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

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

5、数组内嵌文档查询

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

6、数组元素操作符$elemMatch

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

7、数组元素操作符$all

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

8、数组元素操作符$size

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

9、数组元素操作符$slice

作用：用于返回指定位置的数组元素值的子集(是数值元素值得一部分，不是所有的数组元素值)示例：db.collection.find( { field: value }, { array: {$slice: count } } );        //创建演示文档> db.blog.insert(... {_id:1,title:"mongodb unique index",... comment: [... {"name" : "joe","content" : "nice post."},... {"name" : "bob","content" : "good post."},... {"name" : "john","content" : "greatly."}]}... )WriteResult({ "nInserted" : 1 })//通过$slice返回集合中comment数组第一条评论> db.blog.find({},{comment:{$slice:1}}).pretty(){"_id" : 1,"title" : "mongodb unique index","comment" : [{"name" : "joe","content" : "nice post."}]}//通过$slice返回集合中comment数组最后一条评论> db.blog.find({},{comment:{$slice:-1}}).pretty(){"_id" : 1,"title" : "mongodb unique index","comment" : [{"name" : "john","content" : "greatly."}]}//通过$slice返回集合中comment数组特定的评论(可以理解为分页)//如下查询，返回的是第2-3条评论，第一条被跳过> db.blog.find({},{comment:{$slice:[1,3]}}).pretty(){"_id" : 1,"title" : "mongodb unique index","comment" : [{"name" : "bob","content" : "good post."},{"name" : "john","content" : "greatly."}]}

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

使用样式：db.collection.find( { :  ... },{ ".$": 1 } )db.collection.find( { :  ...},{ ".$": 1 } )使用示例> db.students.insertMany([{ "_id" : 1, "semester" : 1, "grades" : [ 70, 87, 90 ] },{ "_id" : 2, "semester" : 1, "grades" : [ 90, 88, 92 ] },{ "_id" : 3, "semester" : 1, "grades" : [ 85, 100, 90 ] },{ "_id" : 4, "semester" : 2, "grades" : [ 79, 85, 80 ] },{ "_id" : 5, "semester" : 2, "grades" : [ 88, 88, 92 ] },{ "_id" : 6, "semester" : 2, "grades" : [ 95, 90, 96 ] }])                                          //通过下面的查询可知，仅仅只有第一个大于等于85的元素值被返回//也就是说$占位符返回的是数组的第一个匹配的值，是数组的子集> db.students.find( { semester: 1, grades: { $gte: 85 } },... { "grades.$": 1 } ){ "_id" : 1, "grades" : [ 87 ] }{ "_id" : 2, "grades" : [ 90 ] }{ "_id" : 3, "grades" : [ 85 ] }> db.students.drop()//使用新的示例数据> db.students.insertMany([{ "_id" : 7, semester: 3, "grades" : [ { grade: 80, mean: 75, std: 8 },{ grade: 85, mean: 90, std: 5 },{ grade: 90, mean: 85, std: 3 } ] },{ "_id" : 8, semester: 3, "grades" : [ { grade: 92, mean: 88, std: 8 },{ grade: 78, mean: 90, std: 5 },{ grade: 88, mean: 85, std: 3 } ] }])//下面的查询中，数组的元素为内嵌文档，同样如此，数组元素第一个匹配的元素值被返回> db.students.find(...    { "grades.mean": { $gt: 70 } },...    { "grades.$": 1 }... ){ "_id" : 7, "grades" : [ { "grade" : 80, "mean" : 75, "std" : 8 } ] }{ "_id" : 8, "grades" : [ { "grade" : 92, "mean" : 88, "std" : 8 } ] }

更新数组中的所有元素

操作符：$[]

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

更新内嵌文档

{"_id" : 1,"grades" : [{ "grade" : 80, "mean" : 75, "std" : 8 },{ "grade" : 85, "mean" : 90, "std" : 6 },{ "grade" : 85, "mean" : 85, "std" : 8 }]
}
{"_id" : 2,"grades" : [{ "grade" : 90, "mean" : 75, "std" : 8 },{ "grade" : 87, "mean" : 90, "std" : 5 },{ "grade" : 85, "mean" : 85, "std" : 6 }]
}db.students2.update({ },{ $inc: { "grades.$[].std" : -2 } },  //更新grade数组中 每个属性位std的值{ multi: true }//更新所有记录
)

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

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

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

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

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

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

$数组更新

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

db.students.insert([{ "_id" : 1, "grades" : [ 85, 80, 80 ] },{ "_id" : 2, "grades" : [ 88, 90, 92 ] },{ "_id" : 3, "grades" : [ 85, 100, 90 ] }
])#将grades数组中第一个值为80更新为82，如果你不知道第一个值的具体位置，就可以像下面这样写：
db.students.updateOne({ _id: 1, grades: 80 },{ $set: { "grades.$" : 82 } }
)#更新数组中的文档
db.collection.update({  },{ : { "array.$.field" : value } }
)
#样例：
{_id: 4,grades: [{ grade: 80, mean: 75, std: 8 },{ grade: 85, mean: 90, std: 5 },{ grade: 85, mean: 85, std: 8 }]
}
#使用$定位符去更新grades数组中文档中字段std的值，被更新的文档是第一个匹配grade值为85的文档
db.students.updateOne({ _id: 4, "grades.grade": 85 },{ $set: { "grades.$.std" : 6 } }
)

条件更新

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

Mongodb--操作符

一、比较操作符

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

二、逻辑操作符

 三、元素操作符

　3.1 $exists

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

　3.2 $type

匹配字段值为指定数据类型的文档
{ field: { $type:  |  } }

示例：
db.big.find({"name":{$type:2}})
db.big.find({"name":{$type:"string"}})

四、评估操作符

 　4.1 $mod

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

　4.2 $regex

语法：
{ : { $regex: /pattern/, $options: '' } }
{ : { $regex: 'pattern', $options: '' } }
{ : { $regex: /pattern/ } }参数：
i:忽略大小写
m:多行匹配
x:忽略空格
s:点号可以匹配换行符示例：
db.big.find({"name":{$regex:/^jun/i}})
db.big.find({"name":{$regex:/^jun/,$options:'i'}})

　4.3 $text

　　MongoDB支持对文本内容执行文本搜索操作，其提供了索引text index和查询操作$text来完成文本搜索功能。只有拥有text index的collection才支持全文检索每个collection只能拥有一个text indexText index可以包含任何的string类型、string数组类型的字段Text index可以包含多个字段使用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查询。

五、数组操作符

foreach 函数

//在函数中依然可以调用
var param = db.sm_pm_paramconfig.find({paramGroup: "BUSINESSUNIT"});//对信息表进行遍历操作
db.userinfo.find().forEach(function(item) {var arr = item.address.split("_");//获取部门名称var deptName = "";var num = -1;for (var i = 0; i < arr.length; i++) {if ("****" == arr[i]) {num = i;break;}}if (num >= 0) {deptName = arr[num + 1];} else {deptName = "****";}var temp=db.Goods.findOne({"goodsCode":{"$regex":"^"+tempGoodCode+".+"}});if(temp){}//插入ID//注意：param获取的对象要toarray一下才能遍历。var config = param.toArray();for (var j = 0, len = config.length; j < len; j++) {if (deptName == config[j].paramValue) {//插入新字段db.userinfo.update({"_id": item._id}, {$set: {"businessUnitId": config[j]._id}});break;}}
})

参考文档：

Query and Projection Operators — MongoDB Manual