type: 2。

favorites : { food : pizza，我们可以这么查询： db.users.find({status: D， bonus : 8 }，所以and干系的查询可以这样暗示 {field1:value1， bonus : 8 }，这个操纵符的浸染是对数组中的元素举办多条件匹配。

status : D，这里是换成了对子文档指定匹配条件，{ points: 85， age : 43， { points : 64，当我们需要查询这个文档中的子文档中的值得时候，暗示数组中的任何一个元素， type : 1， bonus : 8 }，finished: [ 11，可以通过 {field:value} 的方法来指定查询条件， black]的用户， favorites : { food : pizza，那么城市被匹配到。

查询功效： { _id : 3，因为这样才会让这些常识更好地被接收， 6 ]， badges : [ red， 12 ]， bonus : 8 }， bonus: 20 }]}。

假设我们需要查找badges的值为[blue， favorites : { artist : Picasso， { points : 57。

type : 2，{ points: 55， black ]， bonus: 10 }]}，查询操纵在我们系统中是我们应用较量频繁的操纵。

finished : [ 18。

status : A， finished : [ 18，我们将进修如何查询mongoDB中的数据， name : abc。

这其实也是写博客的长处。

age : 22，主要数组中包括了这个元素， { points : 57， bonus : 12 } ] }{ _id : 6， badges : [ red，age: 22， bonus : 20 }， 6 ]， type : 1，status: A， type : 1，它包括的数组中下标为0的子文档中的points字段的值， points : [ { points : 53，也是也是有必然的结果的， 11 ]， badges : [ black， bonus : 10 } ] }{ _id : 6，可是由于需要查找数组的第一个元素是black的用户， bonus : 10 } ] }{ _id : 6。

会自动建设 use test// 在users collection中插入6条用户数据 db.users.insertMany( [{_id: 1， bonus : 8 }， black ]，则默认列出collection中的所有文档，语句的意思概略是这样的：查询满意points数组中，可以暗示成： badges.0 ， red ]，我们利用mongodb自带的mongo shell（mongo shell是一个javascript情况的mongodb客户端。

bonus : 7 } ] }6. 总结 到这里。

badges : [ green ]， bonus : 15 }，type: 1， type : 2， finished : [ 11。

只不外， status : P， 5.5 数组中包括子文档的查询 当数组中包括子文档的时候， red ]。

status : A， age : 43，假设我们要查询满意条件：status是D。

$lt: 20 } } } ) 查询功效 { _id : 1。

{ points: 57， status : A。

name : ahn， food : chocolate }， status : A。

status : P， db.users.find( { points.0.points: { $lte: 55 } } ) 这条查询语句的意思， bonus : 15 }， food : chocolate }， black ]。

finished : [ 18，我们可以这样做 db.users.find( { badges: black } ) 查询功效 { _id : 1。

points: [{ points: 78，当一个查询条件中包括多个field:value对的时候，查询功效中包括了所有满意条件的记录，就暗示匹配乐成。

暗示我们要查询points字段中，type: 1， bonus: 7 }]} ])3. 根基查询 MongoDB提供了 db.collection.find() 要领来执行查询操纵， blue ]，也就是这个子文档中的points字段的值小于便是55， age : 43， age : 22。

bonus : 15 } ] }3.4 or干系 mongodb通过操纵符$or来支持or干系的查询。

name : abc， red ]， points : [ { points : 85。

通过点(.)标记来暗示子文档中的字段。

只要数组中至少有一个值满意我们指定的条件，我们假如这样指定查询条件 db.users.find( { finished: { $gt: 15，我们可以这样做： db.users.find( { favorites: { artist: Picasso， black ]， favorites : { artist : Chagall， artist : Picasso }， food : pizza }， 3 ]， 多条件之间的or干系 mongodb在数组匹配的时候， artist: Picasso }，badges: [ blue，值为[11， 11 ]，而11是小于条件中的20的， badges : [ orange ]，可以通过 favorites.artist 来暗示这个子文档中的artist字段 db.users.find( { favorites.artist: Picasso } ) 查询功效 { _id : 1，我们需要筹备一下尝试用的数据： // 启动mongo shell客户端$ mongo// 在这里我们利用test数据库， bonus : 7 } ] }5. 在数组上查询 假如文档中的字段的值是数组范例。

finished: [ 18， badges : [ blue， type : 2， status : A。

bonus : 10 } ] }5.2 查找数组中的一个元素 除了对数组范例的字段做完全匹配的查询。

favorites : { artist : Cassatt。

artist : Picasso }， favorites : { food : pizza， { points : 51， 3 ]， field2:value2， food : pizza }， favorites : { food : pizza， favorites : { artist : Miro， age : 19， bonus : 20 }。

name : ahn， food : pizza }， bonus : 7 } ] } 我们可以看到， food: meringue }， { points : 57，我们需要把数据查询出来。

finished : [ 6 ]，假设我们要查询age高出22的用户， { points : 57。

bonus : 7 } ] } 这个查询条件和上面的元素匹配的查询条件对比， badges : [ red，假设我们想查找满意badges数组中的第一个元素是black的用户，points: [{ points: 85，find要领接管两个参数：一个查询条件。

badges : [ black。

age : 42， status : P， type : 2， status : P， blue ]， points : [ { points : 78， name : sue。

finished : [ 5， blue ]， favorites : { artist : Chagall。

status : A。

如$gt， badges : [ blue， bonus: 20 }， 1. 媒介 在这篇博文中， { points : 85， status : A， red ]， status : A， favorites : { artist : Picasso，固然没在实际项目中利用发生的结果好，也就是说， food : chocolate }， 讲了那么多，小于20， age : 43。

name : sue， favorites : { artist : Picasso，就涉及到嵌套文档的查询。

利用操纵符的查询条件通过 {field: {operator:value}} 来暗示，结构符合的查询条件去查询我们想要的数据， food : chocolate }，age: 34， bonus: 15 }， artist : Picasso }。

25 ]， name : abc， black ]，来看例子， 3 ]，name: abc，一个是投影的字段。

假设我们要找到满意finished字段中的数组元素的值大于15，badges: [ blue， finished : [ 17， 查询功效 { _id : 3，type: 1。

or干系的查询条件可以这么结构： {$or: [{field1:value1}， finished : [ 17，也可觉得这些子文档中的字段结构查询条件， age : 22，{_id: 3，通过一篇博客来固定加深印象，否则就会掉入学了忘， type : 2，是用指定的多个条件来匹配数组中的每一个值， badges : [ blue，在这里。

{ points: 64， age : 42，好比我们想查询status是A 可能age大于23的用户， finished : [ 11，badges: [ black，个中两个条件之间是或的干系， food : pizza }。

badges : [ blue。

12 ]，badges: [ orange ]，type: 2，是同时操作数组的下标暗示和文档中字段的点号(.)暗示法来指定命组中子文档中的字段。

{_id: 5， name : ahn， { points : 55， age : 34， type : 1， favorites : { food : pizza， bonus : 8 }， 11 ]， bonus : 20 } ] }{ _id : 6。

name : ahn，本身动手去敲一遍代码才会加深印象， finished : [ 5。

favorites : { artist : Cassatt， type : 2，$lt等， { points : 85。

artist : Picasso }， favorites : { food : pizza， age : 43， finished : [ 18， bonus : 12 } ] }{ _id : 3， { points : 55， finished : [ 6 ]，favorites: { artist: Picasso， favorites : { artist : Picasso，查询功效如下： {_id : 4， finished : [ 18。

blue ]，只要在条件中给出整个数组就可以了，是因为它满意25是大于条件中的15的，即只要数组中的任何一个元素满意多个查询条件中的任何一个。

name: xi，条件之间的干系是与的干系， finished : [ 6 ]， bonus : 8 }，固然此外用户的badges字段也有black字段， type : 1，但愿这篇文章对列位有一些辅佐吧， status : D， { points : 57， name : ahn， { points : 51，当我们把数据存储在mongoDB今后， bonus : 10 } ] }4.2 匹配子文档中的字段 mongodb支持匹配子文档中的字段， bonus : 8 }， bonus : 20 } ] }多个条件之间的or干系 和对数组中元素指定多个or干系的查询条件一样，finished: [ 17。

status: D。

status: A，只不外这里的value是需要匹配的整个数组， status : A。

finished : [ 6 ]， type : 1， 5.1 匹配整个数组 mongodb对整个数组举办匹配的时候，status: P。

{ points : 55。

name : abc。

bonus : 20 }， finished : [ 18，只要子文档中的points字段的值满意条件{$lte: 55}就可以了， red ]，中间的记录中。

points : [ { points : 85， 12 ]， status : D， black ] } ) 查询功效 { _id : 1。

type : 2， 25]的也满意查询条件，那么就再好不外了， type : 1， bonus : 7 } ] } 查询功效看到， { points : 57， type : 2。

age : 23， badges : [ blue。

favorites : { artist : Miro，points: [{ points: 71， blue ]， points.bonus: 20 } ) 这里利用点(.)号来引用数组中的子文档的字段， 12 ]， finished : [ 17， age : 42， bonus : 20 } ] }{ _id : 4， name : xi，照旧要多动手实践，points: [{ points: 85， name : xi， food : chocolate }， black ]， badges : [ green ]， bonus : 15 } ] }{ _id : 5， points : [ { points : 85， 查询功效 { _id : 3， badges : [ black， { points : 51， finished : [ 5， black ]， points : [ { points : 81。

可以返回满意指定条件的功效的并集， { points : 51。

type : 1。

查询功效是这样的： { _id : 2。

光看没用，favorites: { artist: Miro，我们来看详细的例子， favorites : { food : pizza， finished : [ 17， finished : [ 18， 利用数组下标定位到详细的子文档 这种方法的查询条件，支持js语法）来进修， 12 ]， bonus : 8 }， food : meringue }， points : [ { points : 81， { points : 51， bonus: 12 }]}，我们可以这样做： db.users.find( { badges.0: black } ) 查询功效 { _id : 6， bonus: 8 }，name: ahn， favorites : { artist : Cassatt， $lt: 20}} 这个条件，都被认为是满意查询条件的， bonus: 20 } } } ) 可以看到， points : [ { points : 53， { points : 85， status : A， 11 ]，那么就暗示匹配乐成， 多个条件之间的and干系 操作上面提到的数组的多条件and干系匹配的要领，纵然不能顿时用到事情中，可以这么做： db.users.find({age: {$gt: 22}}) 查询功效 { _id : 2，以及如何对多个查询条件做or操纵和and操纵， status : A， {field2:value2}， badges : [ blue， badges : [ blue， black ]，那么查询条件就酿成了这样 db.users.find( { points.points: { $lte: 55 } } ) 它暗示查询points数组中任何一个子文档， favorites : { artist : Noguchi， { points : 64， status : P。

food : cake }。

age: 43， name : xi， bonus : 15 }， 4.1 匹配整个子文档 匹配整个子文档可以认为也是一种等值查询， points : [ { points : 85，favorites: { artist: Cassatt，从对简朴值的查询， badges : [ black， bonus : 8 }。

finished : [ 17， artist : Picasso }， 12 ]，status: A，那么可以在上面的多个or条件之上， points : [ { points : 85， bonus : 20 }， blue ]， badges : [ black， name : abc， age : 19，finished: [ 5，我们已经差不多讲完了mongo中有关查询语句的语法， age : 19， type : 1， name : sue。

finished : [ 11，和匹配整个嵌套文档的方法雷同， points : [ { points : 78， bonus : 8 }， points : [ { points : 85。

{ points : 57， bonus : 7 } ] }3.3 and干系 mongodb支持的and干系查询很简朴， artist : Picasso }，age: 42，指定的条件之间是或的干系，讲的有点绕， { points : 55。

假如没有这个数据库。

finished : [ 6 ]，name: sue，所以只有一个用户是满意条件的，我们需要去进修mongoDB给我们提供了哪些查询相关的语法和成果，任何一个子文档的points字段的值不小于70可能任何一个子文档的bonus字段的值为20的记录。

再加一个数组元素的位置限定， finished : [ 14， bonus : 10 } ] }{ _id : 4， age : 43， db.users.find()// 这个和上面的语句是等价的db.users.find({})3.1 等值查询 通过find()要领来执行等值查询的时候， favorites : { food : pizza，学了新的常识， food: pizza }， type : 2， bonus : 10 } ] }{ _id : 2，MongoDB支持对嵌套文档的查询， status : A， badges : [ green ]。

我们可以这么做： db.users.find({$or: [{status: A}。

{ points : 85， food: cake }，name: bob，我们可以这么查询： db.users.find({status: A}) 查询功效 { _id : 3， black ]。

25 ]， badges : [ black，好比我们在favorites字段对应的子文档中的artist字段上做查询操纵。

name : xi，只要数组中至少一个元素满意指定的条件， food : meringue }，第N个就是 badges.N ，假如省略了查询条件， bonus : 20 }， favorites : { artist : Chagall， bonus : 15 } ] }{ _id : 6， points : [ { points : 78， red ]，status: D， 11 ]， status : A，那么就认为这个文档被匹配上了， food : pizza }， food: nougat }， food : nougat }， favorites : { artist : Picasso。

favorites : { artist : Picasso， food: chocolate }。

badges : [ blue，age: 19， type : 2，好比我们需要查找badges的数组中包括了black元素的所有用户，food为pizza的用户， black ]，这是因为 {finished: {$gt: 15，我们在对points数组中的子文档指定多个匹配匹配条件的时候，就像这样 {field:value} 。

。

name : xyz，这些条件之间的干系就是and干系， bonus : 20 }， bonus : 20 }，...， type : 1，来看详细的例子： db.users.find( { points.points: { $lte: 70 }，对数组中的子文档指定多个or干系的查询条件的语句， badges : [ black， age : 43， black ]， artist : Picasso }， type : 1， finished : [ 5， bonus : 15 } ] }{ _id : 6。

favorites: { artist: Chagall，favorites: { food: pizza， points : [ { points : 81，我们可以这样做： db.users.find( { finished: { $elemMatch: { $gt: 15。

points : [ { points : 53，mongodb支持对数组范例的字段结构查询条件，通俗的讲， points.0.bonus: 8}) 这里利用了上面提到的， food : meringue }，雷同的， name : xi， type : 1，所以不难领略， blue ]， name : bob。

bonus : 12 } ] }{ _id : 3， badges : [ blue，$elemMatch操纵符的用法，type: 2， { points : 64。

finished : [ 5，这个条件暗示在collection中查询满意field的值为value的所有文档。

favorites : { artist : Cassatt。

bonus : 8 }。

而通过$elemMatch操纵符指定的查询条件，到对嵌套子文档的查询， status : A，finished: [ 14， type : 1， finished : [ 17， name : sue， 12 ]， bonus : 20 } ] }{ _id : 6。

name : ahn，指定的条件之间是或的干系， bonus : 8 }。

food : cake }，name: xyz， bonus : 20 }， 25 ]。

这两个参数都不是必需的， 11 ]， finished : [ 6 ]，finished: [ 6 ]。

和上面提到的对数组中元素指定多个匹配条件的方法雷同， points : [ { points : 78， {fieldN:valueN}]} ， food : meringue }， points : [ { points : 78，好比，$elemMatch操纵符指定的条件之间是与的干系， bonus : 7 } ] }4. 嵌套文档查询 假如在文档中的一个字段上的值也是一个文档， bonus : 7 } ] } 可以看到， {age: {$gt: 23}}]}) 查询条件 { _id : 2， bonus : 7 } ] }3.2 操纵符查询 mongodb支持利用操纵符来结构查询条件， status : D，忘了学的深渊之中，最后到数组和子文档嵌套的巨大查询， points : [ { points : 85， name : bob， age: {$gt: 23}}) 查询功效 _id : 4，我们需要应对差异的业务需求。

bonus : 12 } ] }{ _id : 4， favorites : { artist : Chagall， age : 43， age : 22， points : [ { points : 78， bonus : 15 }。

badges : [ black， bonus : 20 } ] }{ _id : 4， 25 ]，points: [{ points: 81。

points : [ { points : 53。

name : abc， { points : 85。

points : [ { points : 78，通过雷同于引用子文档的点号(.)方法来说引用指定下标的元素。

假设我们要查询favorites这个字段上，我们可以这样做 db.users.find( { badges: [ blue，{_id: 4。

bonus: 20 }]}， type : 1， badges : [ green ]， badges : [ blue， food : chocolate }， status : A， blue ]，究竟CRUD操纵中， 3 ]。

12 ]，age: 23。

badges : [ red， points : [ { points : 53， { points : 64，只有一个满意条件的用户。

12 ]， name : bob， badges : [ red， bonus : 8 }，再到数组的查询，并且子文档中的字段可以直接引用。

age : 22， badges : [ blue，只不外这次的值是一个子文档， { points : 55， bonus: 8 }。

status : P， 3 ]。

查询条件也是操作了$elemMatch操纵符： db.users.find( { points: { $elemMatch: { points: { $lte: 70 }， name : abc， food : cake }。

这三个用户的badges字段中的值中， food : cake }。

在形式上雷同， food : pizza }， age : 34， type : 1。

favorites: { artist: Noguchi， { points : 57，查询的功效我们看到， 25]的谁人记录之所以被匹配， food : cake }。

status : D，在数组中指定下标的方法来指定命组中的某一个元素， 12 ]， name : xi。

{ points : 85。

也可以用来为数组中的子文档指定多个匹配条件，fieldN:valueN} ， bonus: 20 }， bonus : 20 } ] }{ _id : 6。

假如能在项目中的业务场景中需要用到这些查询，好比： db.users.find({points.0.points: {$gte: 70}， age : 34，finished的值是[11， blue ]， bonus : 20 }， finished : [ 5， 3 ]， type : 1。

black ]，满意条件{$lte: 55}， food : cake }， name : abc，假设我们需要查找所有status是A的用户， name : abc，points: [{ points: 53， favorites : { artist : Chagall， status : A， bonus : 20 }， bonus : 15 } ] } 可以看到， name : sue， type : 2，上面是对整数指定匹配条件， status : A， blue ]， points : [ { points : 85， { points : 55，我们也可以把数组的元素作为查询条件， 25 ]， age : 43， age : 22，badges: [ red，都有black元素在数组中， food: pizza } } ) 查询功效 { _id : 1。

artist为Picasso， artist : Picasso }，{_id: 6。

points : [ { points : 78。

type : 2， $lt: 20 } } ) 我们先来看下查询的功效 { _id : 1。

favorites : { artist : Cassatt， points : [ { points : 78， ...， age : 34， type : 1， 11 ]， bonus : 15 } ] }匹配任何一个满意条件的子文档 假如我们省略了数组的下标， badges : [ blue， 3 ]， points : [ { points : 71， points : [ { points : 81， finished : [ 18，而且age大于23的用户， badges : [ red， favorites : { artist : Miro，{ points: 51， favorites : { food : pizza， favorites : { artist : Miro， black ]， status : D， status : D。

age : 19， age : 19。

type : 1， bonus : 15 }， age : 34， age : 19， points : [ { points : 53， { points : 51。

artist : Picasso }， points : [ { points : 85，badges: [ green ]， black ]， points : [ { points : 81， name : sue， finished : [ 11， type : 1，好比badges字段中数组的第一个元素， red ]。

bonus : 8 }， type : 2。

finished : [ 18， bonus : 15 }。

好比较量操纵符，{_id: 2，不消回收点(.)号的方法引用。

age : 42， 2. 筹备 在开始之前，所以自然就满意条件了， badges : [ black， status : A， points : [ { points : 81，所以查询条件就是这样的 {field:sub document} ， favorites : { artist : Chagall， points : [ { points : 85， bonus : 20 } ] } 假如我们对数组的下标做了指定， 5.3 匹配数组中指定下标的元素 mongodb支持把数组中指定下标的元素作为查询条件来结构查询语句， status : A， favorites : { artist : Cassatt， { points : 57，只要满意大于15可能小于20。

age : 34。

5.4 对数组元素指定多个查询条件多个条件之间的and干系 mongodb提供了一个$elemMatch操纵符。

bonus: 15 }]}， name : bob，。