How do the positional $ operator, $[] and arrayFilters differ when updating arrays?

## The problem these solve When a document holds an array of embedded documents, you often need to change a field inside one specific element without rewriting the array. MongoDB solves this with placeholders in the dotted update path that stand for an array index the server computes at write time. There are three, and they answer three different questions. ## The positional operator: $ ```js db.orders.updateOne( { _id: 1, "items.sku": "abc" }, { $set: { "items.$.qty": 5 } } ) ``` `$` resolves to the index of the **first** array element that satisfied the query condition on that array. Three rules follow from that definition: 1. **The array field must appear in the query filter.** If the filter does not include a condition on `items`, there is no match to refer to and the update fails. 2. **Only the first match is updated.** If three elements have `sku: "abc"`, exactly one changes. This is the single most common surprise in production code. 3. **It cannot be used with an upsert that inserts.** There is no matched array element in a newly created document, so an insert path with `$` errors. You also cannot use `$` more than once in a path, so it cannot reach into a nested array. ## The all-positional operator: $[] ```js db.orders.updateOne( { _id: 1 }, { $inc: { "items.$[].qty": 1 } } ) ``` `$[]` stands for every index of the array. No condition on the array is needed in the filter, and every element is modified. Use it for blanket changes — normalizing a field on all elements, incrementing every counter, stamping every element with a flag. ## The filtered positional operator: $[identifier] with arrayFilters ```js db.orders.updateOne( { _id: 1 }, { $set: { "items.$[el].qty": 5 } }, { arrayFilters: [ { "el.sku": "abc" } ] } ) ``` `$[el]` stands for every index whose element matches the `arrayFilters` entry named `el`. This is the general form and the one to reach for by default: - It updates **all** matching elements, not just the first. - It does not require the array to appear in the query filter, so the filter can stay a plain `_id` lookup. - It works with upserts, because the condition is independent of what the query matched. - It composes for nested arrays: `"a.$[outer].b.$[inner].x"` with `arrayFilters: [ { "outer.k": 1 }, { "inner.k": 2 } ]`. The rules the server enforces: every identifier used in the update must have exactly one matching entry in `arrayFilters`, and every entry in `arrayFilters` must be used by the update — an unused filter or an undeclared identifier is an error. Identifiers must begin with a lowercase letter and contain only alphanumeric characters. Filtered positional updates require MongoDB 3.6 or later, so every currently supported release has them. ## "Update the third matching element" This is the question interviewers like, because it exposes whether you actually know the three forms. Plain `$` gives you the first match only. `$[]` gives you all of them. Neither gives you "the third". Your options are: - If you know the **array index**, address it directly: `{ $set: { "items.2.qty": 5 } }`. That is a plain dotted path, not a positional operator, and it is exact but brittle — the index changes whenever elements are inserted or removed. - If the element has a **stable identifier**, use `arrayFilters` on that identifier: `{ "el.lineId": "L3" }`. This is the durable answer, and it is the reason line items usually carry their own id. - If "third" is genuinely positional and unstable, you generally need to restructure: read the document, find the index, and write with an index path plus a guard in the filter so a concurrent change is detected — or move the elements into their own collection. ## Which one to reach for Use `$` when you have already matched on the array in the filter and you know at most one element can match — it is the shortest form and needs no extra option. Use `$[]` for genuinely blanket changes. Use `arrayFilters` everywhere else: it says exactly which elements you mean, updates all of them, and does not silently stop at the first. A final note on matching semantics: a filter like `{ "items.sku": "abc", "items.qty": 0 }` matches a document where *some* element has that sku and *some* (possibly different) element has that quantity. When your condition genuinely means "one element satisfies both", the filter needs `$elemMatch` — and `$` then resolves against that match. Getting the filter wrong and the positional operator right still updates the wrong element.