个人中心
文章发布
退出
作者热门文章
- Java锁的逻辑（结合对象头和ObjectMonitor）
- 还在用饼状图？来瞧瞧这些炫酷的百分比可视化新图形（附代码实现）⛵
- 自动注册实体类到EntityFrameworkCore上下文，并适配ABP及ABPVNext
- 基于Sklearn机器学习代码实战
26
4
MongoDB中涉及到数组字段的查询和更新很常用，抽空把自己开发工作中常遇到的场景拿出来并结合官方文档小结一下.
有说的不对的地方，欢迎指出交流探讨，也希望这篇笔记能够帮到你。 。
可以转载，但请注明出处。 。
之前自己写的SpringBoot整合MongoDB的聚合查询操作，感兴趣的可以点击查阅.
https://www.cnblogs.com/zaoyu/p/springboot-mongodb.html 。
。
$elemMatch: https://www.mongodb.com/docs/manual/reference/operator/query/elemMatch/ 。
$update: https://www.mongodb.com/docs/manual/reference/operator/update/positional/#mongodb-update-up.- 。
测试环境: MongoDB 5.0.9 。
数组的查询多数情况结合$elemMatch操作符一起查询，也可以不使用。 下面分别是两种情况的演示说明.
1.1 是直接查询，不使用$elemMatch, 1.2是带$elemMatch的查询。 。
具体语法格式见1.1 和1.2开头。 。
。
就是直接 db.collection.find({queryExpression}) 。
以官方提供的Demo来说明 。
//
1. 插入多条数据
db.inventory.insertMany([
{ item:
"journal", qty: 25, tags: ["blank", "red"], dim_cm: [ 14, 21
] },
{ item:
"notebook", qty: 50, tags: ["red", "blank"], dim_cm: [ 14, 21
] },
{ item:
"paper", qty: 100, tags: ["red", "blank", "plain"], dim_cm: [ 14, 21
] },
{ item:
"planner", qty: 75, tags: ["blank", "red"], dim_cm: [ 22.85, 30
] },
{ item:
"postcard", qty: 45, tags: ["blue"], dim_cm: [ 10, 15.25
] }
]);
//
2.1 数组元素完全匹配查询（值、值的个数、顺序，都要完全一致才返回）。
//
这个语句就是查找tags数组下只且只有red/blank两个值的元素，且顺序要为red、blank。
db.inventory.find( { tags: ["red", "blank"
] } )
//
结果可见下图
//
2.2 数组元素部分匹配查询（只要数组元素中的值，部分值匹配要查询的条件，就可以返回，无关顺序）， 要使用 $all 操作符
//
这个语句意思是说，查找tags数组中，只要元素值里面有red和blank(注意，是多个条件同时存在)，就返回，无关顺序。
db.inventory.find( { tags: { $all: ["red", "blank"
] } } )
//
结果可见下图
//
2.3 数组元素单个值匹配和范围查找
//
比如查找元素中包含某个值的文档，或者元素中存在位于查找范围区间的值的文档。
//
2.3.1 这个是查找元素中存在red值的文档，注意，这里不像上面的完全匹配或者部分匹配时使用中括号，而是直接把值带进去。
db.inventory.find( { tags: "red"
} )
//
2.3.2 这个是查找数组元素中存在符合区间范围的值的元素（类似部分匹配），一般会传入$gt/$lt/$gte/$lte/$ne/$eq之类的匹配范围操作符
//
这里是查找 dim_cm数组中，存在大于25的值的元素。
db.inventory.find( { dim_cm: { $gt: 25
} } )
2.3.1和2.3
.2结果见下图
当然也可以使用多条件匹配查询，就是下文要讲到的$elemMatch查询。
大概格式和说明如下，比如 db.inventory.find( { dim_cm: { $elemMatch: { $gt:
22, $lt: 30
} } } ) 说明要查找dim_cm中存在元素值大于22小于30的文档。
具体看下文。
// 2.1的查询结果 。
// 2.2的查询结果 。
// 2.3.1 的查询结果 。
。
// 2.3.2 的查询结果 。
。
以上就是基本的数组查询，如果涉及到嵌套数组（就是数组里面嵌套着对象），无非是在查询条件那里使用对象形式或者多层级字段来查询.
比如存在这样的数据：{ item: "journal", instock: [ { warehouse: "A", qty: 5 }, { warehouse: "C", qty: 15 } ] } .... 这里为了省事，就列一个.
instock数组字段存储着对象 。
//
示例查询语句，意思是说查询instock数组中的元素存在等于 { warehouse: "A", qty: 5 } 的文档。
db.inventory.find( { "instock": { warehouse: "A", qty: 5
} } )
//
意思是说查询instock数组中元素对象中的qty 存在大于等于20的文档。
db.inventory.find( { 'instock.qty': { $lte: 20 } } )
官方的说明、Demo地址： https://www.mongodb.com/docs/manual/tutorial/query-array-of-documents/ 。
。
官方说明： The $elemMatch operator matches documents that contain an array field with at least one element that matches all the specified query criteria. 。
就是说$elemMatch是用来查询数组字段的，如果数组字段中有至少1个元素匹配查询规则，则查询出来这个数组。 。
//
官方标准语法
{ <field>: { $elemMatch: { <query1>, <query2>
, ... } } }
//
field是数组字段名，在$elemMatch中传入查询条件，可多个，用逗号隔开。
举例说明 。
//
先插入数据
db.scores.insertMany( [
{ _id:
1, results: [ 82, 85, 88
] },
{ _id:
2, results: [ 75, 88, 89
] }
] )
//
来个最基本的$elemMatch使用演示
//
语句说明，查找 results数组中存在大于等于80且小于85的元素的文档。（只要元素中有一个匹配，那么这个元素所在的数组的文档就会返回）
db.scores.find(
{ results: { $elemMatch: { $gte:
80, $lt: 85
} } }
)
//
返回结果，
{ "_id" : 1, "results" : [ 82, 85, 88
] }
//
说明： _id=2的数据，没有任何一个元素值在80~85之间，所以不返回。
上面是简单的数组结构的查询。 。
下面演示下元素为对象的数据的查询.
//
1. 插入数据
db.survey.insertMany( [
{
"_id": 1, "results": [ { "product": "abc", "score": 10
},
{
"product": "xyz", "score": 5
} ] },
{
"_id": 2, "results": [ { "product": "abc", "score": 8
},
{
"product": "xyz", "score": 7
} ] },
{
"_id": 3, "results": [ { "product": "abc", "score": 7
},
{
"product": "xyz", "score": 8
} ] },
{
"_id": 4, "results": [ { "product": "abc", "score": 7
},
{
"product": "def", "score": 8
} ] }
] )
//
查询演示， 这里是查询results中元素含有 { product: "xyz", score: { $gte: 8 } --- 也就是product = xyz, score ≥ 8的元素。 只要数组中含有匹配的元素，该数组所在的文档返回。
db.survey.find(
{ results: { $elemMatch: { product:
"xyz", score: { $gte: 8
} } } }
)
//
查询结果 --- 可以看到 product = xyz， score≥8，所以这条 id=3的文档被返回。
{ "_id" : 3, "results" : [ { "product" : "abc", "score" : 7
},
{
"product" : "xyz", "score" : 8
} ] }
//
补充，只要数组中的元素有至少一个匹配查询规则（$elemMatch中的条件）,那么该数组所在的文档就返回，不管数组中其他的元素怎样。
带$elemMatch和不带的查询对比 。
//
不带$elemMatch 查找results.product不等于xyz的文档，是要全部元素做匹配，如果有一个元素不匹配，那条数据所在的文档就不返回。
db.survey.find(
{
"results.product": { $ne: "xyz"
} }
)
//
返回结果
{ "_id" : 4, "results" : [ { "product" : "abc", "score" : 7
},
{
"product" : "def", "score" : 8
} ] }
//
带$elemMatch
db.survey.find(
{
"results": { $elemMatch: { product: { $ne: "xyz"
} } } }
)
//
返回结果，说明，因为是要查找数组results中存在元素product != xyz的文档，只要有一个元素的product != xyz，那么这个元素所在的数组的文档就会返回。 下面 id=1\2\3的第一个元素都为abc， != xyz， 所以返回，哪怕第二个元素的product == xyz。
{ "_id" : 1, "results" : [ { "product" : "abc", "score" : 10
},
{
"product" : "xyz", "score" : 5
} ] }
{
"_id" : 2, "results" : [ { "product" : "abc", "score" : 8
},
{
"product" : "xyz", "score" : 7
} ] }
{
"_id" : 3, "results" : [ { "product" : "abc", "score" : 7
},
{
"product" : "xyz", "score" : 8
} ] }
{
"_id" : 4, "results" : [ { "product" : "abc", "score" : 7
},
{
"product" : "def", "score" : 8 } ] }
可以看到对于数组的查询，带$elemMatch和不带，区别很大。 通常情况下，一般会用$elemMatch，但有时候也会视实际需求来选择。 。
看完了如何查询，现在可以进入第二步——如何更新，因为update()里面有两个主要参数，一个是query， 一个是set。 。
db.collection.updateOne(<filter>, <update>, <options>) filter就是query语句, update就是set语句，还有一个参数配置。 。
。
//
官方标准语法定义
db.collection.update(
<query>,
//
要更新的文档的查询语句
<update>,
//
要更新的内容
{
upsert:
<
boolean
>,
//
可选，true时开启，存在则更新，否则新增，默认为False。
multi: <
boolean
>,
//
可选， true时开启，批量更新符合条件的文档，否则只更新第一条符合条件的文档，默认false。
writeConcern: <document>,
//
可选，写入策略。比如writeConcern:{w:1}, w:1 是默认的writeConcern，表示数据写入到Primary就向客户端发送确认。 这个一般可以先不管，除非有需要再去专门看，否则不带此参数。
collation: <document>,
//
可选，根据不同的语言定制排序规则，比如{collation: {locale: "zh"}} 代表文档处理时，按照中文拼音排序规则来排序处理。 默认情况下，是按照字段值的普通的二机制字符串来排序。 可以先忽略。
arrayFilters: [ <filterdocument1>, ... ],
//
可选，这个对于数组字段的更新很有用，尤其是只需要更新数组中的符合条件的个别元素。 等下下文会有使用演示。
hint: <document|string>,
//
可选， 4.2 版本后新增的东西 强制某个字段使用索引。 尽管mongodb会自动优化处理，但为了避免某个字段没有使用索引，可以强制指定。
let: <document>
//
可选， 5.0 版本后新增的东西 一个变量定义选项，可以让命令的可读性得到提升，
}
)
//
上面的let 选项，如下是一个简易示例。
假设有这几条数据
db.cakeFlavors.insertMany( [
{ _id:
1, flavor: "chocolate"
},
{ _id:
2, flavor: "strawberry"
},
{ _id:
3, flavor: "cherry"
}
] )
//
执行下述语句，用了let 分别定义了 targetFlavor变量，值为cherry， newFlavor变量，值为 orange。 在前面的 query/update 中，对应的匹配值和新的set的值，是用了let中定义的变量名来占位。
db.cakeFlavors.update(
{ $expr: { $eq: [
"$flavor", "$$targetFlavor"
] } },
[ { $set: { flavor:
"$$newFlavor"
} } ],
{ let : { targetFlavor:
"cherry", newFlavor: "orange"
} }
)
上面的意思就是查找flalvor等于targetFlavor(let中定义的变量）的值（也就是cherry）的文档，然后把flavor的值更新成 newFlavor(let中定义的变量)的值（即 orange）。
除了上面标准语法，还有updateOne--更新符合条件的第一条；updateMany--更新多条，replaceOne--替换符合条件的一条。 参数和上面的一样，不赘述.
。
要正确、熟悉地实现针对数组的更新，需要了解学习以下几个数组更新操作符.
基于上述的数组字段的查询，以及update语法，我们可以开始做基于数组的更新操作演示了。非数组字段的更新，请读者自行找官方文档参考学习，此处不赘述.
//
让我们先插入一些数据
db.students.insertMany( [
{
"_id" : 1, "grades" : [ 85, 80, 80
] },
{
"_id" : 2, "grades" : [ 88, 90, 92
] },
{
"_id" : 3, "grades" : [ 85, 100, 90
] }
] )
//
注意，这里用的updateOne，只更新一条。
//
查找_id=1, grades数组中有80的文档。把grades中第一个匹配的元素（就是值为80）替换成 82
db.students.updateOne(
{ _id:
1, grades: 80
},
{ $set: {
"grades.$" : 82
} }
)
//
更新完毕后，可以看到id=1的数据中的grades，第一个80变成82了，后面的80没变。 这就是$，代表占位匹配的第一个元素位置（不是数组的第一个元素）。
{ "_id" : 1, "grades" : [ 85, 82, 80
] }
{
"_id" : 2, "grades" : [ 88, 90, 92
] }
{
"_id" : 3, "grades" : [ 85, 100, 90
] }
//
有人说，如果我要更新所有grades含有 90的数组的第一个匹配元素呢？请看下面语句。
//
使用update，开启批量更新（ {multi:true}）。 查找grades存在90的文档，并把每个文档中的第一个90替换成82.
db.students.update(
{ grades:
90
},
{ $set: {
"grades.$" : 82
} },
{multi:
true
}
)
//
执行后的结果
{ "_id" : 1, "grades" : [ 85, 82, 80
] }
{
"_id" : 2, "grades" : [ 88, 82, 92
] }
{
"_id" : 3, "grades" : [ 85, 100, 82] }
。
上面是比较简单的普通数组，如果数组存储的是对象呢？ 同理的，看代码 。
//
先执行一下把Students的数据清空
db.students.remove({})
//
插入带对象的数组数据
db.students.insertMany( [
{
"_id" : 4
,
"grades"
: [
{
"grade" : 80, "mean" : 75, "std" : 8
},
{
"grade" : 85, "mean" : 90, "std" : 6
},
{
"grade" : 85, "mean" : 85, "std" : 8
}
]
},
{
"_id": 5
,
"grades"
: [
{
"grade": 80, "mean": 75, "std": 8
},
{
"grade": 85, "mean": 90, "std": 5
},
{
"grade": 90, "mean": 85, "std": 3
}
]
}
])
//
执行updateOne
db.students.updateOne(
{ _id:
4, "grades.grade": 85
},
{ $set: {
"grades.$.std" : 10
} }
)
可以看到，成功更新1条.
。
查看结果如下图。 对象数组的操作也一样的。 只更新第一个匹配的元素。 。
上面的例子，没有使用$elemMatch作为匹配查询条件，你要用也可以。 自己尝试.
。
和$的区别是更新符合条件的文档的数组字段中的所有元素。 。
//
还是一样，先清空下数据
db.students.remove({})
//
插入演示数据
db.students.insertMany( [
{
"_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
}
]
}
] )
//
更新所有grades数组中含有grade大于80的文档，使用grades.$[].std表示更新每个匹配文档中的所有元素的std字段值。 这里是统一改成10。
db.students.updateMany(
{
"grades":{$elemMatch:{"grade": {$gt:80
}}}},
{ $set: {
"grades.$[].std" : 10
} },
)
结果看下图
。
假如你要处理的数组字段不是一个对象，只是字符串或者数字，$[]后面不需要接下级字段。 如下参考代码。 。
db.students.updateMany(
{
"grades":{$elemMatch:{"grade": {$gt:80
}}}},
{ $set: {
"grades.$[]" : "随便你写个值" } },
//
这里grades 假设是一个字符串数组。
)
。
写到这里，我们已经分别用$、$[] 实现对第一个匹配的元素、符合条件的所有文档下的所有元素做更新.
有读者可能会问，那么我想只更新文档下的部分元素呢？比如我只想把数组中的grade大于等于87的元素的std换成 22呢？ 。
好问题，对于这种需求，要使用第三种占位符 $[<identifier>]。 。
注意：$[<identifier>] 通常情况下是要和 arrayFilters 一起使用的。语法格式如下 。
db.collection.updateMany(
{
<query conditions> },
//
查询条件
{ <update operator>: { "<array>.$[<identifier>]" : value } },
//
更新内容
{ arrayFilters: [ { <identifier>: <condition> } ] }
//
数组过滤条件
)
请看代码.
//
先清空下数据
db.students.remove({})
//
插入数据
db.students.insertMany( [
{
"_id" : 1, "grades" : [ 95, 92, 90
] },
{
"_id" : 2, "grades" : [ 98, 100, 102
] },
{
"_id" : 3, "grades" : [ 95, 110, 100
] }
] )
//
使用$[<identifier>] 更新
//
查询所有，把grades中≥100的值全部换成333。
db.students.updateMany(
{ },
{ $set: {
"grades.$[element]" : 333
} },
{ arrayFilters: [ {
"element": { $gte: 100
} } ] }
)
注意： identifier的名称可以是任意，但是$set和arrayFilters中的名称要一致。
执行后的数据结果如下。
。
可以看到，上面只更新了匹配的文档中的符合arrayFilters条件的元素.
有人又问，你这是一个简单的数组，可以演示下对象数组吗？ 可以，看代码。 。
//
还是先清空数据
db.students.remove({})
//
插入数据
db.students.insertMany( [
{
"_id" : 1
,
"grades"
: [
{
"grade" : 80, "mean" : 75, "std" : 5
},
{
"grade" : 85, "mean" : 100, "std" : 4
},
{
"grade" : 85, "mean" : 100, "std" : 5
}
]
},
{
"_id" : 2
,
"grades"
: [
{
"grade" : 90, "mean" : 100, "std" : 5
},
{
"grade" : 87, "mean" : 100, "std" : 3
},
{
"grade" : 85, "mean" : 100, "std" : 4
}
]
}
] )
//
查询所有，把所有grades中的grade ≥ 85的元素中的mean更新为111
db.students.updateMany(
{ },
{ $set: {
"grades.$[elem].mean" : 111
} },
{ arrayFilters: [ {
"elem.grade": { $gte: 85
} } ] }
)
注意： arrayFilters的elem要和set中的$[elem]中的elem一致。 是一个标识符。 可以任意，但要一致。
执行后结果如下图
。
讲到这里，对于数组字段中的元素编辑基本上可以满足开发需求， 再小结下。 。
除了上面3个占位符，mongodb 数组中的更新还有几个操作符（$addToSet, $pop, $pull, $push, $pullAll），下面逐一介绍。 。
AddToSet
// 语法格式：
{ $addToSet: { <field1>: <value1>, ... } } // 字段名：值
//
插入一条演示数据
db.inventory.insertOne(
{ _id:
1, item: "polarizing_filter", tags: [ "electronics", "camera"
] }
)
//
使用addToSet 添加一个元素到Tags中。
db.inventory.updateOne(
{ _id:
1
},
{ $addToSet: { tags:
"accessories"
} }
)
可以看到 accessories 作为元素追加到了tags数组中 。
当要插入的元素已经存在，可以看到modified是0，也就是没更新.
// 作用，删除数组中的第一个或者最后一个元素。
// 语法格式
{ $pop: {
<field>: <-1 | 1>
, ... } }
其中
-1， 1
分别代表数组的第一个元素和最后一个元素
//
插入数据
db.students.insertOne( { _id: 1, scores: [ 8, 9, 10
] } )
//
删除scores数组的第一个元素（-1）
db.students.updateOne( { _id: 1 }, { $pop: { scores: -1
} } )
//
再次查看 结果如下
{ _id: 1, scores: [ 9, 10
] }
可以看到第一个元素
8 已经被删掉。
// 作用： 把一个元素加入到数组中。
// 语法
{ $push: { <field1>: <value1>
, ... } }
// 插入数据
db.students.insertMany( [ { _id: 2, scores: [ 45, 78, 38, 80, 89 ] } , { _id: 3, scores: [ 46, 78, 38, 80, 89 ] } , { _id: 4, scores: [ 47, 78, 38, 80, 89 ] } ] ) // 批量更新，对每个文档都往scores中追加一个元素 95. db.students.updateMany( { }, { $push: { scores: 95 } } ) // 再次查询 结果 [ { _id: 1, scores: [ 44, 78, 38, 80, 89, 95 ] }, { _id: 2, scores: [ 45, 78, 38, 80, 89, 95 ] }, { _id: 3, scores: [ 46, 78, 38, 80, 89, 95 ] }, { _id: 4, scores: [ 47, 78, 38, 80, 89, 95 ] } ]
//
作用：删除数组中的指定元素（通过查询条件），
//
注意和 $pullAll的区别， pullAll是删除所有指定值元素， pull是传入查询条件，删除符合条件的元素。
// 语法格式
{ $pull: { <field1>: <value|condition>, <field2>: <value|condition>
, ... } }
//
插入数据
db.stores.insertMany( [
{
_id:
1
,
fruits: [
"apples", "pears", "oranges", "grapes", "bananas"
],
vegetables: [
"carrots", "celery", "squash", "carrots"
]
},
{
_id:
2
,
fruits: [
"plums", "kiwis", "oranges", "bananas", "apples"
],
vegetables: [
"broccoli", "zucchini", "carrots", "onions"
]
}
] )
//
删掉fruits中所有apples, oranges元素，删掉vegatables中所有carrots元素。
db.stores.updateMany(
{ },
{ $pull: { fruits: { $
in
: [ "apples", "oranges" ] }, vegetables: "carrots"
} }
)
//
执行后结果
{
_id:
1
,
fruits: [
'pears', 'grapes', 'bananas'
],
vegetables: [
'celery', 'squash'
]
},
{
_id:
2
,
fruits: [
'plums', 'kiwis', 'bananas'
],
vegetables: [
'broccoli', 'zucchini', 'onions'
]
}
请注意和$pull的区别 。
//
作用，传入指定值，删除数组中元素为指定值的所有元素，和$pull的区别是，pull是依赖于传入的查询条件，删除匹配查询条件的元素。
//
语法格式
{ $pullAll: { <field1>: [ <value1>, <value2>
... ], ... } }
//
插入数据
db.survey.insertOne( { _id: 1, scores: [ 0, 2, 5, 5, 1, 0
] } )
//
执行
db.survey.updateOne( { _id: 1 }, { $pullAll: { scores: [ 0, 5
] } } )
//
删除 0，5的元素，再次查询，结果如下
{ "_id" : 1, "scores" : [ 2, 1 ] }
。
希望这篇文章能帮到大家，有错漏之处，欢迎指正。 。
完.
。
最后此篇关于MongoDB数组查询（$elemMatch）、更新操作(占位符$)详解的文章就讲到这里了,如果你想了解更多关于MongoDB数组查询（$elemMatch）、更新操作(占位符$)详解的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。
26
4
0
全称“Java Virtual Machine statistics monitoring tool”（statistics 统计；monitoring 监控；tool 工具） 用于监控虚拟机的各种运
主要是讲下Mongodb的索引的查看、创建、删除、类型说明，还有就是Explain执行计划的解释说明。 可以转载，但请注明出处。
1>单线程或者单进程 相当于短链接，当accept之后，就开始数据的接收和数据的发送，不接受新的连接，即一个server，一个client 不存在并发。 2>循环服务器和并发服务器
详解 linux中的关机和重启命令 一 shutdown命令 shutdown [选项] 时间 选项： ?
首先，将json串转为一个JObject对象： ? 1
matplotlib官网 matplotlib库默认英文字体 添加黑体（‘SimHei'）为绘图字体 代码： plt.rcParams['font.sans-serif']=['SimHei'
在并发编程中，synchronized关键字是常出现的角色。之前我们都称呼synchronized关键字为重量锁，但是在jdk1.6中对synchronized进行了优化，引入了偏向锁、轻量锁。本篇
一般我们的项目中会使用1到2个数据库连接配置，同程艺龙的数据库连接配置被收拢到统一的配置中心，由DBA统一配置和维护，业务方通过某个字符串配置拿到的是Connection对象。
实例如下： ? 1
1. MemoryCahe NetCore中的缓存和System.Runtime.Caching很相似，但是在功能上做了增强，缓存的key支持object类型；提供了泛型支持；可以读缓存和单个缓存
argument是javascript中函数的一个特殊参数，例如下文，利用argument访问函数参数，判断函数是否执行 复制代码 代码如下: <script
一不小心装了一个Redis服务，开了一个全网的默认端口，一开始以为这台服务器没有公网ip，结果发现之后悔之莫及啊 某天发现cpu load高的出奇，发现一个minerd进程 占了大量cpu，googl
今天写这个是为了 提醒自己 编程过程 不仅要有逻辑 思想 还有要规范 代码 这样可读性 1、PHP 编程规范与编码习惯最主要的有以下几点： 1 文件说明 2 funct
摘要：虚拟机安装时一般都采用最小化安装，默认没有lspci工具。一台测试虚拟网卡性能的虚拟机，需要lspci工具来查看网卡的类型。本文描述了在一个虚拟机中安装lspci工具的具体步骤。 由于要测试
1、修改用户进程可打开文件数限制 在Linux平台上，无论编写客户端程序还是服务端程序，在进行高并发TCP连接处理时，最高的并发数量都要受到系统对用户单一进程同时可打开文件数量的限制(这是因为系统
目录 算术运算符 基本四则运算符 增量赋值运算符 自增/自减运算符 关系运算符 逻
如下所示： ? 1
MapperScannerConfigurer之sqlSessionFactory注入方式讲解 首先，Mybatis中的有一段配置非常方便，省去我们去写DaoImpl（Dao层实现类）的时间，这个
Linux的网络虚拟化是LXC项目中的一个子项目，LXC包括文件系统虚拟化，进程空间虚拟化，用户虚拟化，网络虚拟化，等等，这里使用LXC的网络虚拟化来模拟多个网络环境。 本文从基本的网络设备讲
? 1
我是一名优秀的程序员,十分优秀！