MongoDB（5）文档 CRUD 操作

关注

原创最新推荐文章于 2026-07-10 10:45:51 发布 614 阅读 AI 写同款· GEO 优化 ›

3个技巧，让你的.NET Core与MongoDB性能提升5倍！《.NET Core与MongoDB集成三步指南》摘要： 1️⃣ 环境配置：创建.NET Core项目，添加MongoDB.Driver依赖，配置连接字符串 2️⃣ 基础集成：通过依赖注入注册MongoDB服务，构建MongoDB工具类实现统一操作接口 3️⃣ 高级操作：使用自定义属性关联实体类与集合，封装CRUD方法实现用户管理 🔥 亮点：采用泛型工具类+属性标注设计，使代码复用率提升40%，通过实战案例详解配置陷阱与优化方案。阅读详情

MongoDB 入门专栏

http://blog.youkuaiyun.com/column/details/19681.html

MongoDB 文档 CRUD 操作

查询文档

基本使用

mongodb 查询文档的语法如下：

          
         db.collection_name.find(query, projection)           # 以压缩格式返回数据
        
         db.collection_name.find(query, projection).pretty()  # 以易读格式返回数据

query：可选，使用查询操作符指定查询条件；
projection：可选，使用投影操作符指定返回的键，如果需要返回文档中所有的键，只需要省略该参数；

          
         # 查询 testdb.artciles 集合中的所有文档
        
         > use testdb
        
         > db.articles.find().pretty()    
        
         ​
        
         # 查询 testdb.articles 集合中 author='assad' 的文档
        
         > db.atricles.find( { author:'assad' } )

query 条件操作符

操作符	含义和语法	示例
比较查询符
:	等于(=)； { <key>:<value> }	db.col.find( { name:'assad' } ) 查询 name='assad' 的文档
$ne	不等于(!=)； { <key>:{$ne:<value>} }	db.col.find( { name:{$ne:'assad'} } ) 查询 name!='assad' 的文档
$lt	小于(<)： { <key>:{$lt:<value>} }	db.col.find( { score:{$lt:120} } ) 查询 score>120 的文档
$gt	大于(>)； { <key>:{$gt:<value>} }	db.col.find( { score:{$gt:120} } ) 查询 score<120 的文档
$lte	小于等于(<=)； { <key:{$lte:<value>} }	db.col.find( { score:{$lte:120} } ) 查询 score<=120 的文档
$gte	大于等于(>=)； { <key>:{$gte:<value>} }	db.col.find( { score:{$gte:120} } ) 查询 score>= 120 的文档
逻辑关系查询符
$and	and 和关系； { $and:[query1, query2] } { query1, query2 }	db.col.find( { $and:[{city:'guangzhou'}, { score:{$gt:250} }] }) db.col.find( { city:'guangzhou', score:{$gt:250} } 查询 city='guangzhou' and core>250 的文档
$or	or 或关系； { $or:[query1, query2] }	db.col.find( { $or:[{city:'guangzhou'}, { score:{$gt:250 }}] }) 查询 city='guangzhou' or core>250 的文档
$nor	nor 异或关系； { $nor:[query1, query2] }	db.col.find( { $nor:[{city:'guangzhou'}, { score:{$gt:250 }}] }) 查询 (city='guangzhou' or core<=250) and (city!='guangzhou' and core > 250)的文档
$not	非关系； { $not:{query} }	db.col.find( { $not:{city:'guangzhou'} }) 查询 city!= 'guanhgzhou' 的文档
成员关系查询符
$all	查询 key 匹配指定数组中的所有成员的结果； { <key>:{$all:[ array ]} }	db.col.find( { tages:{$all:['java','cpp','linux']} } ) 查询 tages 字段数组中含有 'java','cpp','linux' 全部这些值的文档
$in	查询 key 匹配指定数组中任一个成员的结果； { <key>:{$in:[ array ]} }	db.col.find( { tages:{$in:['java','cpp','linux']} } ) 查询 tages 字段数组中含有 'java','cpp','linux' 中任意一个值的文档
$nin	查询 key 不匹配指定数组中任一个成员的结果； { <key>:{$in:[ array ]} }	db.col.find( { tages:{$in:['java','cpp','linux']} } ) 查询 tages 字段数组中不含有 'java','cpp','linux' 的文档
.	查询 key 指定下标成员，index从0开始； { <key.index>:query}	db.col.find( { tages.1:‘java’ } ) 查询 tages 字段数组第 2 个元素 = ‘java' 的文档
值属性查询符
$size	查询指定长度的数组 { <key>:{$size:value} }	db.col.find( { tages:{$size:3} } ) 查询 tages 字段数组长度为 3 的文档，可以结合比较查询符使用
$type	查询指定类型的 key，具体类型列表见: https://docs.mongodb.com/manual/reference/operator/query/type/index.html { <key> :{$type: typecode} }	db.col.find( { title:{$type:2 } } ) 查询 title 类型为 String 的文档
$exits	查询指定存在条件的 key 的文档 { <key>:{$exists:<boolean>} }	db.col.find( { school:{$exits:false} } ) 查询不存在 school 字段的所有文档
null	其实不是操作符，是作为空值的占位符 { <key>:null } {<key>:{$in:[null]} }	db.col.find( { school:null } ) 查询 school 字段不存在，或者 school 字段值为空的文档 db.col.find( { school:{$in:[null], $exists:true} } ) 查询 school 字段存在，但是值为空的文档
$regex	对字符串进行正则匹配，使用perl兼容表达式，可以用达到类似 SQL like 子句的效果； { <key>:{$regex:pattern, $options:ops} } 其中 $options 用于修饰 regex，参数如下： -i：忽略大小写; -x：强制对没有标注 \n 的字符串分行; - s：pattern 中的点号匹配所有字符（包括换行符）; -x：忽略 pattern 中没有转义的特殊字符;	db.col.find( { name:{$regix:"^a"} } ) db.col.find( { name:/^a/ } } ) 查询 name 以 a 开头的文档 db.col.find( { name:{$regex: "^a", $options:'i'}} ) db.col.find( { name:/^a/i }) 查询 name 以 a 开头的文档，或略大小写
$where	使用任意 JavaScript 作为查询的一部分，包括 Js 表达式和 Js 闭包； { $where: javascript-operation } 在Js 表达式中，使用 this，obj 指代每个文档对象	db.col.find( { $where: "this.score > this.salary " } ) db.col.find( { $where: "obj.score = this.salary" } ) db.col.find( { $where:function() {return (this.score > this.salary )} } ) 查询 col 中所有 score > salary 的文档；

          
         > use testdb
        
         # 查询 testdb.articles 集合中 author="assad" 的文档
        
         > db.articles.find( { author:'assad' } )
        
         ​
        
         # 查询 likes > 1000 的文档
        
         > db.articles.find( { likes:{$gt:1000} } )
        
         ​
        
         # 查询 likes 大于 1000 ，小于 1500 的文档
        
         > db.artciles.find( { likes:{$gt:1000, $lt:1500} } )
        
         ​
        
         # 查询 author="assad" 同时 likes > 2000 的文档
        
         > db.articles.find( { author:'assad', likes:{$gt:2000} } )
        
         ​
        
         # 查询 authoer="assad" 或 "vancy" 的文档
        
         > db.articles.find( { author:{$in:['assad','vancy']} } )
        
         ​
        
         # 查询 tages 数组同时含有 'java','groovy' 的文档
        
         > db.articles.find( { tages:{ $all:['java','groovy']} } )
        
         ​
        
         # 查询 title 中含有 'java' 字段

查询返回结果处理

使用 find() 函数的 projection 参数限定返回键

          
         # 查询 testdb.article 集合中所有的文档，只返回 title，author，这2个键(默认会返回 _id 键)
        
         > db.articles.find( {}, {title:1, author:1} )
        
         { "_id" : ObjectId("5a83c281a04c12209d79eea3"),"title" : "groovy refrence","author" : "assad" }
        
         { "_id" : ObjectId("5a83c5a0a04c12209d79eea4"),"title" : "spring refrence","author" : "alex" }
        
         ​
        
         # 同上，不返回 _id 键
        
         > db.articles.find( {}, {title:1, author:1, _id:0} )
        
         { "title" : "groovy refrence", "author" : "assad" }
        
         { "title" : "spring refrence", "author" : "alex" }

$slice 操作符

使用 $slice 操作符可以限定返回的文档的个数；

          
         # 返回前 20 个文档
        
         > db.articles.find( {}, { _id:{$slice:20} } )
        
         # 返回包含有 titles 的前20个文档
        
         > db.articles.find( {}, { titles:{$slice:20} } )
        
         ​
        
         # 返回包含有 titles 从第 20 项之后的 10 项；
        
         > db.articles.find( {}, { titles:{$slice:[ 20, 10 ]} } )
        
         # 返回包含有 titles 从倒数第 20 项之后的 10 项；
        
         > db.articles.find( {}, { titles:{$slice:[ -20, 10 ]} } )

skip()，limit() 方法

以上使用 $slice 操作符限制显示结果数量，可以使用 skip()，limit() 函数来代替；

          
         # 返回前20个文档
        
         > db.articles.find().limit(20)
        
         # 返回从第 20 项之后的 10 项；
        
         > db.articles.find().skip(20).limit(10)

sort() 方法

sort() 方法用于对查询结果进行排序，方法原型如下，其中 key 为按该键进行排序，1 表示正序，-1表示倒叙：

db.colletion_name.find().sort({<key>:<1|-1>})

          
         # 返回结果按 likes 正序排序
        
         > db.artciles.find().sort(likes:1)
        
         ​

查询内嵌文档

mongo 对于内嵌文档的查询和数组的操作方式是一样的，如以下文档：

          
         { 
        
             _id : ObjectId("51d7b0d436332e1a5f7299d6"),
        
             "name" : {
        
                 "first" : "Van",
        
                 "last" : "Darkholme"
        
              },
        
              "comments" : "Deep Dark Fanstatic"
        
         }

其中 "name" 的值为一个内嵌文档

          
         # 查询 name.first = "Van" 的文档
        
         > db.nobodyknown.find( { name: {first:"Van"} } );
        
         # 查询 name.first = "Van", name.last 包含 "Dark" 的文档
        
         > db.nobodyknown.find( { name:{first:"Van", last:{$regex:"*Dark*"}} } )

查询分组与数据聚合

mongodb 如果实现类似 SQL 查询中的 group 子句、count()、avg() 等统计聚合方法，可以使用聚合方法 aggregate() 详见： 06. MongoDB 数据聚合操作

插入文档

mongodb 使用 insert() 方法插入文档，语法如下：

db.collection_name.insert(document)

示例：

          
         # 在 testdb 库中的 articles 集合中插入一条记录
        
         > use testdb
        
         >  db.articles.insert({
        
         ... title:'groovy refrence',
        
         ... author:'assad',
        
         ... tages:['groovy','java'],
        
         ... like:2333
        
         ... })

插入日期类型

可以使用 new Date() 来创建一个日期类型的值，使用示例如下：

          
         # 插入当前时间值
        
         >  db.logdate.insert( { ip:'255.33.21.36', logDate:new Date() } )  
        
         .....
        
         # 插入指定时间值
        
         >  db.logdate.insert( { ip:'255.33.21.36', logDate:ISODate('2018-02-12 15:33:00') } )   #指定时间

更新文档

update() 方法

update() 方法用于更新已经存在的文档，语法如下：

          
         db.collection_name.update( <query>, <update>, { upset:<boolean>, muti:<boolean>,writeConcern:<document>} )

query：update 的查询条件，详细语法同查询的 query 参数（可以理解为 sql update 的 where 子句）；
update：更新的对象和一些更新的操作符，比如 $set 操作符（可以理解为 sql update 的 set 子句）；
upset：可选，指明如果不存在 update 的记录时，是否插入新的文档对象，默认为 false 不插入；
muti：可选，true 表示更新全部查找到的文档，false 表示只更查找到的第一条文档，默认为 false；
writeConsern：可选，指明抛出异常的级别；

其中 update 中常用操作符如下：

操作符	含义和语法	示例
$set	将某个键的值设置为其他值 { $set:{<key1>:<val1>, <key2>:<val2>，...} }	db.col.update( {name:'assad'},{$set:{name:'assad2'}} ) 将 name='assad' 的文档的 name 更新为 'assad2'
$inc	对某个键的值进行自增操作（使用负数表示自减） { $inc:{<key1>:<amount1>, <key2>:<amount2>，...} }	db.col.update( {name:'assad'}, {$inc:{score:10}} ) 将 name='assad' 的文档的 score + 10

示例：

          
         > use testdb
        
         # 将 author='assad' 的文档的 title 设置为 '花Q！'
        
         > db.articles.update( {name:'assad'}, {$set:{title:'花Q！'}} )
        
         ​
        
         # 将 score >= 2500 的文档 score - 100, level + 5 
        
         > db.users.update( {score:{$gte:250}}, {$inc:{score:-100, level:5}} )

save() 方法

save() 方法使用传入的文档替换掉已有的文档，语法如下：

db.collection.save( <document>, { writeConcern: <document> } )

如下示例：

          
         >db.article.save({
        
             "_id" : ObjectId("56064f89ade2f21f36b03136"),
        
             "title" : "MongoDb",
        
             "author" : "assad",
        
             "tags" : [
        
                     "mongodb",
        
                     "nosql"
        
             ],
        
             "likes" : 110
        
         })

删除文档

mongodb 使用 remove() 方法删除文档，语法如下：

db.collection.remove( <query>, { justOne：<boolean>, writeConcern:<document> )

query :（可选）删除的文档的条件；
justOne : （可选）如果设为 true 或 1，则只删除一个文档'；
writeConcern :（可选）抛出异常的级别；

示例：

          
         # 删除 article 集合中所有 author="assad" 的文档
        
         > db.artciles.remove( {author:'assad'},{justOne:false} )
        
         ​
        
         # 删除 artciles 集合中的所有文档
        
         > db.articles.remove( {},{justOne:false} )