3、db.find(query, callback)

作用：

查询符合条件的文档集。

参数：

query： object 类型，查询条件。支持使用比较运算符 ($lt, $lte, $gt, $gte, $in, $nin, $ne), 逻辑运算符 ($or, $and, $not, $where), 正则表达式进行查询。

callback(可选): 回调函数，包含参数 err 以及 docs，err 是报错，docs 是查询到的文档集。

示例：

  1. // 数据存储集合
  2. // { _id: 'id1', planet: 'Mars', system: 'solar', inhabited: false, satellites: ['Phobos', 'Deimos'] }
  4. // { _id: 'id2', planet: 'Earth', system: 'solar', inhabited: true, humans: { genders: 2, eyes: true } }
  6. // { _id: 'id3', planet: 'Jupiter', system: 'solar', inhabited: false }
  8. // { _id: 'id4', planet: 'Omicron Persei 8', system: 'futurama', inhabited: true, humans: { genders: 7 } }
  10. // { _id: 'id5', completeData: { planets: [ { name: 'Earth', number: 3 }, { name: 'Mars', number: 2 }, { name: 'Pluton', number: 9 } ] } }
  13. // 示例1： 基本查询。可以使用正则表达式匹配字符串。使用“.”匹配对象或者数组里面的元素。
  15. // 单字段查询
  16. db.find({system:'solar'},function(err,docs){
  17.   // docs is an array containing documents Mars, Earth, Jupiter
  18.   // If no document is found, docs is equal to []
  19. });
  23. // 正则表达式查询
  24. db.find({planet:/ar/},function(err,docs){
  25.   // docs contains Mars and Earth
  26. });
  29. // 多条件查询
  30. db.find({system:'solar',inhabited:true},function(err,docs){
  31.   // docs is an array containing document Earth only
  32. });
  35. // 根据对象属性查询
  36. db.find({"humans.genders":2},function(err,docs){
  37.   // docs contains Earth
  38. });
  41. // 根据数组对象属性查询
  42. db.find({"completeData.planets.name":"Mars"},function(err,docs){
  43.   // docs contains document 5
  44. });
  48. db.find({"completeData.planets.name":"Jupiter"},function(err,docs){
  49.   // docs is empty
  50. });
  53. db.find({"completeData.planets.0.name":"Earth"},function(err,docs){
  54.   // docs contains document 5
  55.   // If we had tested against "Mars" docs would be empty because we are matching against a specific array element
  56. });
  59. // 对象深度比较查询，不要与"."使用混淆
  60. db.find({humans:{genders:2}},function(err,docs){
  61.   // docs is empty, because { genders: 2 } is not equal to { genders: 2, eyes: true }
  62. });
  65. // 查询所有结果集
  66. db.find({},function(err,docs){
  68. });
  71. // 查询某一个文档
  72. db.findOne({_id:'id1'},function(err,doc){
  73.   // doc is the document Mars
  75.   // If no document is found, doc is null
  77. });
  80. // 示例2： {field: {$op: value}} ($op代表任意比较运算符)
  82. // $lt, $lte: 小于，小于等于
  84. // $gt, $gte: 大于，大于等于
  86. // $in: 属于
  88. // $ne, $nin: 不等于，不属于
  90. // $exists: 取值为true或者false，用于检测文档是否具有某一字段
  92. // $regex: 检测字符串是否与正则表达式相匹配
  96. // $lt, $lte, $gt and $gte 只能用于数字和字符串类型
  98. db.find({"humans.genders":{$gt:5}},function(err,docs){
  100.   // docs contains Omicron Persei 8, whose humans have more than 5 genders (7).
  102. });
  105. // 当进行字符串比较的时候，将使用字典序。
  106. db.find({planet:{$gt:'Mercury'}},function(err,docs){
  108.   // docs contains Omicron Persei 8
  110. })
  113. // Using $in. $nin is used in the same way
  114. db.find({planet:{$in:['Earth','Jupiter']}},function(err,docs){
  116.   // docs contains Earth and Jupiter
  118. });
  122. // Using $exists
  123. db.find({satellites:{$exists:true}},function(err,docs){
  125.   // docs contains only Mars
  127. });
  130. // Using $regex with another operator
  131. db.find({planet:{$regex:/ar/,$nin:['Jupiter','Earth']}},function(err,docs){
  133.   // docs only contains Mars because Earth was excluded from the match by $nin
  135. });
  138. // 示例3： 当文档中有一个字段是数组，NeDB将首先判断查询值是否为数组，如果是数组的话将执行精确查找，然后再去判断是否存在数组比较方法(现在只支持$size和$elemMatch)。如果都没有，将会对所有元素进行查询。
  140. // $size: 匹配数组的大小
  142. // $elemMatch: 匹配至少一个数组元素
  145. // 精确查找
  146. db.find({satellites:['Phobos','Deimos']},function(err,docs){
  148.   // docs contains Mars
  150. })
  152. db.find({satellites:['Deimos','Phobos']},function(err,docs){
  154.   // docs is empty
  156. })
  159. // 使用数组比较方法
  161. // $elemMatch 运算符将匹配数组中满足所有条件的元素
  163. db.find({completeData:{planets:{$elemMatch:{name:'Earth',number:3}}}},function(err,docs){
  165.   // docs contains documents with id 5 (completeData)
  167. });
  170. db.find({completeData:{planets:{$elemMatch:{name:'Earth',number:5}}}},function(err,docs){
  172.   // docs is empty
  174. });
  177. // 在$elemMatch中使用比较运算符
  178. db.find({completeData:{planets:{$elemMatch:{name:'Earth',number:{$gt:2}}}}},function(err,docs){
  180.   // docs contains documents with id 5 (completeData)
  182. });
  185. // 注意不能使用嵌套的运算符, e.g. { $size: { $lt: 5 } } 将会抛出异常
  187. db.find({satellites:{$size:2}},function(err,docs){
  189.   // docs contains Mars
  191. });
  194. db.find({satellites:{$size:1}},function(err,docs){
  196.   // docs is empty
  198. });
  201. // If a document's field is an array, matching it means matching any element of the array
  203. db.find({satellites:'Phobos'},function(err,docs){
  205.   // docs contains Mars. Result would have been the same if query had been { satellites: 'Deimos' }
  207. });
  210. // This also works for queries that use comparison operators
  211. db.find({satellites:{$lt:'Amos'}},function(err,docs){
  213.   // docs is empty since Phobos and Deimos are after Amos in lexicographical order
  215. });
  218. // This also works with the $in and $nin operator
  219. db.find({satellites:{$in:['Moon','Deimos']}},function(err,docs){
  221.   // docs contains Mars (the Earth document is not complete!)
  223. });
  226. // 示例4： 逻辑运算符 $or, $and, $not, $where
  228. // $or, $and: 并集，交集 { $op: [query1, query2, ...] }
  230. // $not: 取非 { $not: query }
  232. // $where: 条件 { $where: function () { /* object is "this", return a boolean */ } }
  235. db.find({$or:[{planet:'Earth'},{planet:'Mars'}]},function(err,docs){
  237.   // docs contains Earth and Mars
  239. });
  242. db.find({$not:{planet:'Earth'}},function(err,docs){
  244.   // docs contains Mars, Jupiter, Omicron Persei 8
  246. });
  249. db.find({$where:function(){returnObject.keys(this)>6;}},function(err,docs){
  251.   // docs with more than 6 properties
  253. });
  256. // You can mix normal queries, comparison queries and logical operators
  257. db.find({$or:[{planet:'Earth'},{planet:'Mars'}],inhabited:true},function(err,docs){
  259.   // docs contains Earth
  261. });
  264. // 示例5: Projections
  266. // 在第二个参数传入projections对象，来规定返回字段。比如： {a:1, b:1}指定只返回a和b字段，{a:0, b:0}指定省略a和b这两个字段。
  268. // _id默认返回，不需要返回设置_id: 0
  272. // Same database as above
  275. // Keeping only the given fields
  277. db.find({planet:'Mars'},{planet:1,system:1},function(err,docs){
  279.   // docs is [{ planet: 'Mars', system: 'solar', _id: 'id1' }]
  281. });
  284. // Keeping only the given fields but removing _id
  286. db.find({planet:'Mars'},{planet:1,system:1,_id:0},function(err,docs){
  288.   // docs is [{ planet: 'Mars', system: 'solar' }]
  290. });
  293. // Omitting only the given fields and removing _id
  295. db.find({planet:'Mars'},{planet:0,system:0,_id:0},function(err,docs){
  297.   // docs is [{ inhabited: false, satellites: ['Phobos', 'Deimos'] }]
  299. });
  302. // Failure: using both modes at the same time
  304. db.find({planet:'Mars'},{planet:0,system:1},function(err,docs){
  306.   // err is the error message, docs is undefined
  308. });
  311. // You can also use it in a Cursor way but this syntax is not compatible with MongoDB
  313. db.find({planet:'Mars'}).projection({planet:1,system:1}).exec(function(err,docs){
  315.   // docs is [{ planet: 'Mars', system: 'solar', _id: 'id1' }]
  317. });
  320. // Project on a nested document
  322. db.findOne({planet:'Earth'}).projection({planet:1,'humans.genders':1}).exec(function(err,doc){
  324.   // doc is { planet: 'Earth', _id: 'id2', humans: { genders: 2 } }
  326. });
  329. // 示例6：排序和分页
  331. // 文档集
  333. // doc1 = { _id: 'id1', planet: 'Mars', system: 'solar', inhabited: false, satellites: ['Phobos', 'Deimos'] }
  335. // doc2 = { _id: 'id2', planet: 'Earth', system: 'solar', inhabited: true, humans: { genders: 2, eyes: true } }
  337. // doc3 = { _id: 'id3', planet: 'Jupiter', system: 'solar', inhabited: false }
  339. // doc4 = { _id: 'id4', planet: 'Omicron Persei 8', system: 'futurama', inhabited: true, humans: { genders: 7 } }
  342. // No query used means all results are returned (before the Cursor modifiers)
  344. db.find({}).sort({planet:1}).skip(1).limit(2).exec(function(err,docs){
  346.   // docs is [doc3, doc1]
  348. });
  351. // You can sort in reverse order like this
  353. db.find({system:'solar'}).sort({planet:-1}).exec(function(err,docs){
  355.   // docs is [doc1, doc3, doc2]
  357. });
  360. // You can sort on one field, then another, and so on like this:
  362. db.find({}).sort({firstField:1,secondField:-1})...   // You understand how this works!