Docs Home → MongoDB Manual

db.collection.findOneAndUpdate()

On this page本页内容

Definition定义

db.collection.findOneAndUpdate( filter, update, options )
Important

mongosh Method

This page documents a mongosh method. 本页记录了一个mongosh方法。This is not the documentation for database commands or language-specific drivers, such as Node.js.这不是数据库命令或特定语言驱动程序（如Node.js）的文档。

For the database command, see the update command.

For MongoDB API drivers, refer to the language-specific MongoDB driver documentation.

For the legacy mongo shell documentation, refer to the documentation for the corresponding MongoDB Server release:

mongo shell v4.4

Updates a single document based on the filter and sort criteria.根据filter和sort条件更新单个文档。

The findOneAndUpdate() method has the following form:findOneAndUpdate()方法的形式如下：

db.collection.findOneAndUpdate(
   <filter>,
   <update document or aggregation pipeline>, // Changed in MongoDB 4.2
   {
     writeConcern: <document>,
     projection: <document>,
     sort: <document>,
     maxTimeMS: <number>,
     upsert: <boolean>,
     returnDocument: <string>,
     returnNewDocument: <boolean>,
     collation: <document>,
     arrayFilters: [ <filterdocument1>, ... ]
   }
)

The findOneAndUpdate() method takes the following parameters:findOneAndUpdate()方法采用以下参数：

Parameter参数Type类型Description描述
filterdocumentThe selection criteria for the update. 更新的选择条件。The same query selectors as in the find() method are available.可以使用与find()方法中相同的查询选择器。
To update the first document returned in the collection, specify an empty document { }.若要更新集合中返回的第一个文档，请指定一个空文档{ }。
If unspecified, defaults to an empty document.如果未指定，则默认为空文档。
Starting in MongoDB 4.2, the operation returns an error if the query field is not a document.从MongoDB 4.2开始，如果查询字段不是文档，则操作会返回错误。
If no document matches the filter, no document is updated. 如果没有与filter匹配的文档，则不会更新任何文档。
updatedocument or arrayThe update document or, starting in MongoDB 4.2, an aggregation pipeline. 更新文档，或者从MongoDB 4.2开始的聚合管道。
writeConcerndocumentOptional.可选的。A document expressing the write concern.表示写入关注的文档。 Omit to use the default write concern. 忽略使用默认的写入关注。
{ w: <value>, j: <boolean>, wtimeout: <number> }
Do not explicitly set the write concern for the operation if run in a transaction. To use write concern with transactions, see Transactions and Write Concern. 如果在事务中运行，请不要显式设置操作的写入关注。要在事务中使用写入关注，请参阅事务和写入关注。
projectiondocumentOptional.可选的。A subset of fields to return.要返回的字段的子集。
To return all fields in the returned document, omit this parameter.若要返回返回文档中的所有字段，请省略此参数。
Starting in MongoDB 4.2 (and 4.0.12+, 3.6.14+, and 3.4.23+), the operation errors if the projection argument is not a document. 从MongoDB 4.2（以及4.0.12+、3.6.14+和3.4.23+）开始，如果投影参数不是文档，则操作会出错。
sortdocumentOptional.可选的。Specifies a sorting order for the documents matched by the filter.为filter匹配的文档指定排序顺序。
Starting in MongoDB 4.2 (and 4.0.12+, 3.6.14+, and 3.4.23+), the operation errors if the sort argument is not a document.从MongoDB 4.2（以及4.0.12+、3.6.14+和3.4.23+）开始，如果排序参数不是文档，则操作会出错。
See cursor.sort(). 请参见cursor.sort()。
maxTimeMSnumberOptional.可选的。Specifies a time limit in milliseconds within which the operation must complete within. 指定操作必须在内完成的时间限制（以毫秒为单位）。Throws an error if the limit is exceeded.如果超过限制，则抛出错误。
upsertbooleanOptional.可选的。When true, findOneAndUpdate() either: 如果为true，则findOneAndUpdate()：
  • Creates a new document if no documents match the filter. For more details see upsert behavior. 如果没有与filter匹配的文档，则创建新文档。有关更多详细信息，请参阅upsert行为。Returns null after inserting the new document, unless returnNewDocument is true.插入新文档后返回null，除非returnNewDocument为true。
  • Updates a single document that matches the filter.更新与filter匹配的单个文档。
To avoid multiple upserts, ensure that the filter field(s) are uniquely indexed.为避免出现多个upsert，请确保对filter字段进行唯一索引。
Defaults to false, which does not insert a new document when no match is found. 默认为false，在找不到匹配项时不插入新文档。
returnDocumentstringOptional.可选的。Starting in mongosh 0.13.2, returnDocument is an alternative for returnNewDocument. 从mongosh 0.13.2开始，returnDocument是returnNewDocument的替代方案。If both options are set, returnDocument takes precedence.如果同时设置了这两个选项，则returnDocument优先。
returnDocument: "before" returns the original document. returnDocument: "after" returns the updated document. returnDocument: "before"返回原始文档。returnDocument: "after"返回更新后的文档。
returnNewDocumentbooleanOptional.可选的。When true, returns the updated document instead of the original document.如果为true，则返回更新后的文档，而不是原始文档。
Defaults to false.
collationdocumentOptional.可选的。
Specifies the collation to use for the operation.指定要用于操作的排序规则。
collation allows users to specify language-specific rules for string comparison, such as rules for lettercase and accent marks.允许用户为字符串比较指定特定于语言的规则，例如字母大小写和重音标记的规则。
The collation option has the following syntax: collation选项具有以下语法：
collation: {
   locale: <string>,
   caseLevel: <boolean>,
   caseFirst: <string>,
   strength: <int>,
   numericOrdering: <boolean>,
   alternate: <string>,
   maxVariable: <string>,
   backwards: <boolean>
}
When specifying collation, the locale field is mandatory; all other collation fields are optional. 指定排序规则时，locale字段是必需的；所有其他排序规则字段都是可选的。For descriptions of the fields, see Collation Document.有关字段的说明，请参阅排序规则文档。
If the collation is unspecified but the collection has a default collation (see db.createCollection()), the operation uses the collation specified for the collection.如果未指定排序规则，但集合具有默认排序规则（请参见db.createCollection()），则操作将使用为集合指定的排序规则。
If no collation is specified for the collection or for the operations, MongoDB uses the simple binary comparison used in prior versions for string comparisons.如果没有为集合或操作指定排序规则，MongoDB将使用以前版本中使用的简单二进制比较进行字符串比较。
You cannot specify multiple collations for an operation. 不能为一个操作指定多个排序规则。For example, you cannot specify different collations per field, or if performing a find with a sort, you cannot use one collation for the find and another for the sort. 例如，不能为每个字段指定不同的排序规则，或者如果使用排序执行查找，则不能为查找使用一个排序规则，为排序使用另一个排序顺序。
arrayFiltersarrayOptional.可选的。An array of filter documents that determine which array elements to modify for an update operation on an array field.一组筛选文档，用于确定要为数组字段的更新操作修改哪些数组元素。
In the update document, use the $[<identifier>] filtered positional operator to define an identifier, which you then reference in the array filter documents. 在更新文档中，使用$[<identifier>]筛选的位置运算符来定义标识符，然后在数组筛选文档中引用该标识符。You cannot have an array filter document for an identifier if the identifier is not included in the update document. 如果标识符未包含在更新文档中，则不能为该标识符设置数组筛选器文档。
Note
The <identifier> must begin with a lowercase letter and contain only alphanumeric characters. <identifier>必须以小写字母开头，并且仅包含字母数字字符。
You can include the same identifier multiple times in the update document; however, for each distinct identifier ($[identifier]) in the update document, you must specify exactly one corresponding array filter document. 您可以在更新文档中多次包含相同的标识符；但是，对于更新文档中的每个不同标识符（$[identifier]），必须指定一个对应的数组筛选器文档。That is, you cannot specify multiple array filter documents for the same identifier. 也就是说，不能为同一标识符指定多个数组筛选器文档。For example, if the update statement includes the identifier x (possibly multiple times), you cannot specify the following for arrayFilters that includes 2 separate filter documents for x: 例如，如果更新语句包含标识符x（可能多次），则不能为arrayFilters指定以下内容，因为arrayFilters包含两个单独的x筛选文档：
// INVALID

[
  { "x.a": { $gt: 85 } },
  { "x.b": { $gt: 80 } }
]
However, you can specify compound conditions on the same identifier in a single filter document, such as in the following examples: 但是，您可以在单个筛选器文档中对同一标识符指定复合条件，例如以下示例：
// Example 1
[
  { $or: [{"x.a": {$gt: 85}}, {"x.b": {$gt: 80}}] }
]
// Example 2
[
  { $and: [{"x.a": {$gt: 85}}, {"x.b": {$gt: 80}}] }
]
// Example 3
[
  { "x.a": { $gt: 85 }, "x.b": { $gt: 80 } }
]
For examples, see Array Update Operations with arrayFilters. 有关示例，请参阅使用arrayFilters的数组更新操作。
Note
arrayFilters is not available for updates that use an aggregation pipeline. 请注意，arrayFilters不适用于使用聚合管道的更新。

Returns返回

Returns the original document by default. Returns the updated document if returnNewDocument is set to true or returnDocument is set to after.默认情况下返回原始文档。如果returnNewDocument设置为true或returnDocument设置为after，则返回更新的文档。

Behavior行为

Document Match文档匹配

db.collection.findOneAndUpdate() updates the first matching document in the collection that matches the filter. 更新集合中与filter匹配的第一个匹配文档。If no document matches the filter, no document is updated.如果没有与filter匹配的文档，则不会更新任何文档。

The sort parameter can be used to influence which document is updated.sort参数可用于影响更新的文档。

Projection投影

Important

Language Consistency语言一致性

Starting in MongoDB 4.4, as part of making find() and findAndModify() projection consistent with aggregation's $project stage,从MongoDB 4.4开始，作为使find()和findAndModify()投影与聚合的$project阶段一致的一部分，

The projection parameter takes a document in the following form:projection参数采用以下形式的文档：

{ field1 : <value>, field2 : <value> ... }
Projection投影Description描述
<field>: <1 or true>Specifies the inclusion of a field. If you specify a non-zero integer for the projection value, the operation treats the value as true.指定包含字段。如果为投影值指定非零整数，则操作会将该值视为true。
<field>: <0 or false>Specifies the exclusion of a field.指定字段的排除。
"<field>.$": <1 or true>Uses the $ array projection operator to return the first element that matches the query condition on the array field. 使用$投影运算符返回与数组字段上的查询条件匹配的第一个元素。If you specify a non-zero integer for the projection value, the operation treats the value as true.如果为投影值指定非零整数，则操作会将该值视为true。
Not available for views. 不可用于视图。
<field>: <array projection>Uses the array projection operators ($elemMatch, $slice) to specify the array elements to include.使用数组投影运算符（$elemMatch，$slice）指定要包含的数组元素。
Not available for views. 不可用于视图。
<field>: <aggregation expression>Specifies the value of the projected field.指定投影字段的值。
Starting in MongoDB 4.4, with the use of aggregation expressions and syntax, including the use of literals and aggregation variables, you can project new fields or project existing fields with new values. 从MongoDB 4.4开始，通过使用聚合表达式和语法，包括使用文字和聚合变量，您可以投影新字段或使用新值投影现有字段。
  • If you specify a non-numeric, non-boolean literal (such as a literal string or an array or an operator expression) for the projection value, the field is projected with the new value, for example: 如果为投影值指定非数字、非布尔文字（如文字字符串、数组或运算符表达式），则字段将使用新值进行投影，例如：
    • { field: [ 1, 2, 3, "$someExistingField" ] }
    • { field: "New String Value" }
    • { field: { status: "Active", total: { $sum: "$existingArray" } } }
  • To project a literal value for a field, use the $literal aggregation expression, for example: 要为字段投影文字值，请使用$literal聚合表达式，例如：
    • { field: { $literal: 5 } }
    • { field: { $literal: true } }
    • { field: { $literal: { fieldWithValue0: 0, fieldWithValue1: 1 } } }
In versions 4.2 and earlier, any specification value (with the exception of the previously unsupported document value) is treated as either true or false to indicate the inclusion or exclusion of the field. 在版本4.2及更早版本中，任何规范值（以前不支持的文档值除外）都被视为true或false，以指示包含或排除字段。
New in version 4.4. 4.4版新增。

Embedded Field Specification嵌入式字段规范

For fields in an embedded documents, you can specify the field using either:对于嵌入文档中的字段，可以使用以下任一项指定字段：

  • dot notation, for example 点表示法，例如"field.nestedfield": <value>
  • nested form, for example { field: { nestedfield: <value> } } (Starting in MongoDB 4.4)嵌套形式，例如{ field: { nestedfield: <value> } }（从MongoDB 4.4开始）

_id Field Projection字段投影

The _id field is included in the returned documents by default unless you explicitly specify _id: 0 in the projection to suppress the field.id字段默认包含在返回的文档中，除非您在投影中明确指定_id:0以取消显示该字段。

Inclusion or Exclusion包含或排除

A projection cannot contain both include and exclude specifications, with the exception of the _id field:projection不能同时包含include和exclude规范，_id字段除外：

  • In projections that explicitly include fields, the _id field is the only field that you can explicitly exclude.在显式包含字段的投影中，_id字段是唯一可以显式排除的字段。
  • In projections that explicitly excludes fields, the _id field is the only field that you can explicitly include; however, the _id field is included by default.在显式排除字段的投影中，_id字段是唯一可以显式包含的字段；但是，_id字段在默认情况下是包含在内的。

For more information on projection, see also:有关投影的更多信息，另请参见：

Sharded Collections分片集合

To use db.collection.findOneAndUpdate() on a sharded collection, the query filter must include an equality condition on the shard key.要在分片集合上使用db.collection.findOneAndUpdate()，查询筛选器必须在分片键上包含相等条件。

Starting in version 4.4, documents in a sharded collection can be missing the shard key fields. 从4.4版本开始，分片集合中的文档可能会缺少分片键字段。To target a document that is missing the shard key, you can use the null equality match in conjunction with another filter condition (such as on the _id field). 要针对缺少分片键的文档，可以将null相等匹配与另一个筛选条件结合使用（例如在_id字段上）。For example:例如：

{ _id: <value>, <shardkeyfield>: null } // _id of the document missing shard key

Shard Key Modification分片键修改

Starting in MongoDB 4.2, you can update a document's shard key value unless the shard key field is the immutable _id field. 从MongoDB 4.2开始，您可以更新文档的分片-key值，除非分片-key字段是不可变的_id字段。In MongoDB 4.2 and earlier, a document's shard key field value is immutable.在MongoDB 4.2及更早版本中，文档的分片键字段值是不可变的。

Warning

Starting in version 4.4, documents in sharded collections can be missing the shard key fields. Take precaution to avoid accidentally removing the shard key when changing a document's shard key value.从4.4版本开始，分片集合中的文档可能会缺少分片键字段。请采取预防措施，避免在更改文档的分片键值时意外删除分片键。

To modify the existing shard key value with db.collection.findOneAndUpdate():要使用db.collection.findOneAndUpdate()修改现有的分片键值，请执行以下操作：

  • You must run on a mongos. 必须在mongos上运行。Do not issue the operation directly on the shard.不要直接在分片上发出操作。
  • You must run either in a transaction or as a retryable write.必须在事务中运行或作为可重试写入运行。
  • You must include an equality filter on the full shard key.您必须在完整分片键上包含一个相等筛选器。

Missing Shard Key缺少分片键

Starting in version 4.4, documents in a sharded collection can be missing the shard key fields. 从4.4版本开始，分片集合中的文档可能会缺少分片键字段。To use db.collection.findOneAndUpdate() to set the document's missing shard key,要使用db.collection.findOneAndUpdate()设置文档缺少的分片键，

  • You must run on a mongos. 必须在mongos上运行。Do not issue the operation directly on the shard.不要直接在分片上发出操作。
  • You must run either in a transaction or as a retryable write if the new shard key value is not null.如果新的分片键值不为null，则必须在事务中运行或作为可重试写入运行。
  • You must include an equality filter on the full shard key.必须在完整分片键上包含一个相等筛选器。
Tip

Since a missing key value is returned as part of a null equality match, to avoid updating a null-valued key, include additional query conditions (such as on the _id field) as appropriate.由于丢失的键值是作为null相等匹配的一部分返回的，为了避免更新null值的键，请酌情包括额外的查询条件（例如在_id字段上）。

See also:

Transactions事务

db.collection.findOneAndUpdate() can be used inside multi-document transactions.可以在多文档事务中使用。

Important

In most cases, multi-document transaction incurs a greater performance cost over single document writes, and the availability of multi-document transactions should not be a replacement for effective schema design. 在大多数情况下，与单文档写入相比，多文档事务会产生更高的性能成本，并且多文档事务的可用性不应取代有效的模式设计。For many scenarios, the denormalized data model (embedded documents and arrays) will continue to be optimal for your data and use cases. 对于许多场景，非规范化数据模型（嵌入文档和数组）将继续是您的数据和用例的最佳选择。That is, for many scenarios, modeling your data appropriately will minimize the need for multi-document transactions.也就是说，对于许多场景，对数据进行适当建模将最大限度地减少对多文档事务的需求。

For additional transactions usage considerations (such as runtime limit and oplog size limit), see also Production Considerations.有关其他事务使用注意事项（如运行时限制和操作日志大小限制），请参阅生产注意事项。

Upsert within Transactions事务中的Upsert

Starting in MongoDB 4.4, you can create collections and indexes inside a multi-document transaction if the transaction is not a cross-shard write transaction.从MongoDB 4.4开始，如果多文档事务不是跨分片写入事务，则可以在该事务内创建集合和索引。

Specifically, in MongoDB 4.4 and greater, db.collection.findOneAndUpdate() with upsert: true can be run on an existing collection or a non-existing collection. 具体来说，在MongoDB 4.4及更高版本中，具有upsert:true的db.collection.findOneAndUpdate()可以在现有集合或不存在的集合上运行。If run on a non-existing collection, the operation creates the collection.如果在不存在的集合上运行，则该操作将创建该集合。

In MongoDB 4.2 and earlier, the operation must be run on an existing collection.在MongoDB 4.2及更早版本中，操作必须在现有集合上运行。

Tip

See also: 另请参阅：

Create Collections and Indexes In a Transaction在事务中创建集合和索引

Write Concerns and Transactions撰写关注事项和事务

Do not explicitly set the write concern for the operation if run in a transaction. 如果在事务中运行，请不要显式设置操作的写入关注。To use write concern with transactions, see Transactions and Write Concern.要在事务中使用写入关注，请参阅事务和写入关注。

Examples实例

Update A Document更新文档

The grades collection contains documents similar to the following:grades集合包含类似于以下内容的文档：

{ _id: 6305, name : "A. MacDyver", "assignment" : 5, "points" : 24 },
{ _id: 6308, name : "B. Batlock", "assignment" : 3, "points" : 22 },
{ _id: 6312, name : "M. Tagnum", "assignment" : 5, "points" : 30 },
{ _id: 6319, name : "R. Stiles", "assignment" : 2, "points" : 12 },
{ _id: 6322, name : "A. MacDyver", "assignment" : 2, "points" : 14 },
{ _id: 6234, name : "R. Stiles", "assignment" : 1, "points" : 10 }

The following operation finds the first document where name : R. Stiles and increments the score by 5:以下操作将查找name : R. Stiles的第一个文档，并将分数增加5：

db.grades.findOneAndUpdate(
   { "name" : "R. Stiles" },
   { $inc: { "points" : 5 } }
)

The operation returns the original document before the update:该操作返回更新前的原始文档：

{ _id: 6319, name: "R. Stiles", "assignment" : 2, "points" : 12 }

If returnNewDocument was true, the operation would return the updated document instead.如果returnNewDocument为true，则操作将返回更新后的文档。

Sort And Update A Document排序和更新文档

The grades collection contains documents similar to the following:grades集合包含类似于以下内容的文档：

{ _id: 6305, name : "A. MacDyver", "assignment" : 5, "points" : 24 },
{ _id: 6308, name : "B. Batlock", "assignment" : 3, "points" : 22 },
{ _id: 6312, name : "M. Tagnum", "assignment" : 5, "points" : 30 },
{ _id: 6319, name : "R. Stiles", "assignment" : 2, "points" : 12 },
{ _id: 6322, name : "A. MacDyver", "assignment" : 2, "points" : 14 },
{ _id: 6234, name : "R. Stiles", "assignment" : 1, "points" : 10 }

The following operation updates a document where name : "A. MacDyver". The operation sorts the matching documents by points ascending to update the matching document with the least points.以下操作将更新一个name : "A. MacDyver"的文档。该操作按points的升序对匹配文档进行排序，以更新具有最少点的匹配文档。

db.grades.findOneAndUpdate(
   { "name" : "A. MacDyver" },
   { $inc : { "points" : 5 } },
   { sort : { "points" : 1 } }
)

The operation returns the original document before the update:该操作返回更新前的原始文档：

{ _id: 6322, name: "A. MacDyver", "assignment" : 2, "points" : 14 }

Project the Returned Document投影返回的文档

The following operation uses projection to only display the _id, points, and assignment fields in the returned document:以下操作使用投影仅显示返回文档中的_id、points和assignment字段：

db.grades.findOneAndUpdate(
   { "name" : "A. MacDyver" },
   { $inc : { "points" : 5 } },
   { sort : { "points" : 1 }, projection: { "assignment" : 1, "points" : 1 } }
)

The operation returns the original document with only the fields specified in the projection document and the _id field as it was not explicitly suppressed (_id: 0) in the projection document.该操作返回原始文档，其中只有projection文档中指定的字段和_id字段，因为它在投影文档中没有被显式抑制（_id:0）。

{ "_id" : 6322, "assignment" : 2, "points" : 14 }

Update Document with Time Limit更新有时限的文档

The following operation sets a 5ms time limit to complete the update:以下操作设置5毫秒的时间限制以完成更新：

try {
   db.grades.findOneAndUpdate(
      { "name" : "A. MacDyver" },
      { $inc : { "points" : 5 } },
      { sort: { "points" : 1 }, maxTimeMS : 5 };
   );
}
catch(e){
   print(e);
}

If the operation exceeds the time limit, it returns:如果操作超过时间限制，则返回：

Error: findAndModifyFailed failed: { "ok" : 0, "errmsg" : "operation exceeded time limit", "code" : 50 }

Update Document with Upsert使用Upsert更新文档

The following operation uses the upsert field to insert the update document if nothing matches the filter:如果没有与filter匹配的内容，则以下操作将使用upsert字段插入更新文档：

try {
db.grades.findOneAndUpdate(
   { "name" : "A.B. Abracus" },
   { $set: { "name" : "A.B. Abracus", "assignment" : 5}, $inc : { "points" : 5 } },
   { sort: { "points" : 1 }, upsert:true, returnNewDocument : true }
);
}
catch (e){
   print(e);
}

The operation returns the following:该操作返回以下内容：

{
   "_id" : ObjectId("5789249f1c49e39a8adc479a"),
   "name" : "A.B. Abracus",
   "assignment" : 5,
   "points" : 5
}

If returnNewDocument was false, the operation would return null as there is no original document to return.如果returnNewDocument为false，则操作将返回null，因为没有要返回的原始文档。

Specify Collation指定排序规则

Collation排序规则 allows users to specify language-specific rules for string comparison, such as rules for lettercase and accent marks.允许用户为字符串比较指定特定于语言的规则，例如字母大小写和重音标记的规则。

A collection myColl has the following documents:集合myColl包含以下文档：

{ _id: 1, category: "café", status: "A" }
{ _id: 2, category: "cafe", status: "a" }
{ _id: 3, category: "cafE", status: "a" }

The following operation includes the collation option:以下操作包括collation选项：

db.myColl.findOneAndUpdate(
   { category: "cafe" },
   { $set: { status: "Updated" } },
   { collation: { locale: "fr", strength: 1 } }
);

The operation returns the following document:该操作返回以下文档：

{ "_id" : 1, "category" : "café", "status" : "A" }

Array Update Operations with arrayFilters使用arrayFilters的数组更新操作

Note

arrayFilters is not available for updates that use an aggregation pipeline.不可用于使用聚合管道的更新。

Starting in MongoDB 3.6, when updating an array field, you can specify arrayFilters that determine which array elements to update.从MongoDB 3.6开始，在更新数组字段时，可以指定arrayFilters来确定要更新的数组元素。

Update Elements Match arrayFilters Criteria更新元素匹配arrayFilters条件

Note

arrayFilters is not available for updates that use an aggregation pipeline.不可用于使用聚合管道的更新。

Create a collection students with the following documents:使用以下文档创建students集合：

db.students.insertMany( [
   { "_id" : 1, "grades" : [ 95, 92, 90 ] },
   { "_id" : 2, "grades" : [ 98, 100, 102 ] },
   { "_id" : 3, "grades" : [ 95, 110, 100 ] }
] )

To modify all elements that are greater than or equal to 100 in the grades array, use the filtered positional operator $[<identifier>] with the arrayFilters option in the db.collection.findOneAndUpdate() method:要修改grades数组中所有大于或等于100的元素，请在db.collection.findOneAndUpdate()方法中使用筛选后的位置运算符$[<identifier>]和arrayFilters选项：

db.students.findOneAndUpdate(
   { grades: { $gte: 100 } },
   { $set: { "grades.$[element]" : 100 } },
   { arrayFilters: [ { "element": { $gte: 100 } } ] }
)

The operation updates the grades field for a single document, and after the operation, the collection has the following documents:该操作会更新单个文档的grades字段，操作完成后，集合将具有以下文档：

{ "_id" : 1, "grades" : [ 95, 92, 90 ] }
{ "_id" : 2, "grades" : [ 98, 100, 100 ] }
{ "_id" : 3, "grades" : [ 95, 110, 100 ] }

Update Specific Elements of an Array of Documents更新文档数组的特定元素

Note

arrayFilters is not available for updates that use an aggregation pipeline.不可用于使用聚合管道的更新。

Create a collection students2 with the following documents:使用以下文档创建集合students2：

db.students2.insertMany( [
   {
      "_id" : 1,
      "grades" : [
         { "grade" : 80, "mean" : 75, "std" : 6 },
         { "grade" : 85, "mean" : 90, "std" : 4 },
         { "grade" : 85, "mean" : 85, "std" : 6 }
      ]
   },
   {
      "_id" : 2,
      "grades" : [
         { "grade" : 90, "mean" : 75, "std" : 6 },
         { "grade" : 87, "mean" : 90, "std" : 3 },
         { "grade" : 85, "mean" : 85, "std" : 4 }
      ]
   }
] )

The following operation finds a document where the _id field equals 1 and uses the filtered positional operator $[<identifier>] with the arrayFilters to modify the mean for all elements in the grades array where the grade is greater than or equal to 85.以下操作查找_id字段等于1的文档，并将筛选后的位置运算符$[<identifier>]与arrayFilters一起使用，以修改grades数组中grade大于或等于85的所有元素的mean（平均值）。

db.students2.findOneAndUpdate(
   { _id : 1 },
   { $set: { "grades.$[elem].mean" : 100 } },
   { arrayFilters: [ { "elem.grade": { $gte: 85 } } ] }
)

The operation updates the grades field for a single document, and after the operation, the collection has the following documents:该操作会更新单个文档的grades字段，操作完成后，集合将具有以下文档：

{
   "_id" : 1,
   "grades" : [
      { "grade" : 80, "mean" : 75, "std" : 6 },
      { "grade" : 85, "mean" : 100, "std" : 4 },
      { "grade" : 85, "mean" : 100, "std" : 6 }
    ]
}
{
   "_id" : 2,
   "grades" : [
      { "grade" : 90, "mean" : 75, "std" : 6 },
      { "grade" : 87, "mean" : 90, "std" : 3 },
      { "grade" : 85, "mean" : 85, "std" : 4 }
   ]
}

Use an Aggregation Pipeline for Updates使用聚合管道进行更新

Starting in MongoDB 4.2, db.collection.findOneAndUpdate() can accept an aggregation pipeline for the update. The pipeline can consist of the following stages:从MongoDB 4.2开始，db.collection.findOneAndUpdate()可以接受更新的聚合管道。管道可由以下阶段组成：

Using the aggregation pipeline allows for a more expressive update statement, such as expressing conditional updates based on current field values or updating one field using the value of another field(s).使用聚合管道可以实现更具表达力的更新语句，例如基于当前字段值表达条件更新，或者使用另一个字段的值更新一个字段。

For example, create a collection students2 with the following documents:例如，使用以下文档创建集合students2：

db.students2.insertMany( [
   {
      "_id" : 1,
      "grades" : [
         { "grade" : 80, "mean" : 75, "std" : 6 },
         { "grade" : 85, "mean" : 90, "std" : 4 },
         { "grade" : 85, "mean" : 85, "std" : 6 }
      ]
   },
   {
      "_id" : 2,
      "grades" : [
         { "grade" : 90, "mean" : 75, "std" : 6 },
         { "grade" : 87, "mean" : 90, "std" : 3 },
         { "grade" : 85, "mean" : 85, "std" : 4 }
      ]
   }
] )

The following operation finds a document where the _id field equals 1 and uses an aggregation pipeline to calculate a new field total from the grades field:以下操作查找_id字段等于1的文档，并使用聚合管道从grades字段计算新的字段total：

db.students2.findOneAndUpdate(
   { _id : 1 },
   [ { $set: { "total" : { $sum: "$grades.grade" } } } ],  // The $set stage is an alias for ``$addFields`` stage
   { returnNewDocument: true }
)
Note

The $set used in the pipeline refers to the aggregation stage $set and not the update operator $set.管道中使用的$set指的是聚合阶段$set，而不是更新运算符$set。

The operation returns the updated document :该操作返回更新后的文档：

{
  "_id" : 1,
  "grades" : [ { "grade" : 80, "mean" : 75, "std" : 6 }, { "grade" : 85, "mean" : 90, "std" : 4 }, { "grade" : 85, "mean" :85, "std" : 6 } ],
  "total" : 250
}