json/docs/mkdocs/docs/features/modifying_values.md

Modifying values

Once a JSON value exists, its content can be changed: elements can be added, replaced, merged, and removed. This page gives an overview of the available operations. For read access, see element access.

Adding to arrays

New elements are appended to an array with push_back or constructed in place with emplace_back. If the value is #!json null, it is converted to an array first, so these functions can also be used to build an array from scratch.

json j;                 // null
j.push_back(1);         // [1]
j.push_back(2);         // [1,2]
j.emplace_back(3);      // [1,2,3]

// operator+= is a shorthand for push_back
j += 4;                 // [1,2,3,4]

Adding to objects

The most common way to add or replace a member is operator[], which inserts the key if it does not exist yet:

json j;
j["name"] = "Mary";     // {"name":"Mary"}
j["name"] = "John";     // {"name":"John"}  (replaced)

emplace inserts a member only if the key is not already present, and reports whether the insertion happened — useful for "add if absent" semantics.

Merging objects

To merge one object into another, update copies all members from another object (similar to Python's dict.update). This is the idiomatic way to combine two objects. It has two modes:

• By default, the merge is shallow: existing keys are overwritten, even if both values are objects.
• With merge_objects = #!cpp true, keys whose values are objects in both JSON values are merged recursively. Everything else is overwritten. In particular, arrays are replaced, not concatenated.

??? example

```cpp
--8<-- "examples/update.cpp"
```

Output:

```json
--8<-- "examples/update.output"
```

A common use of the recursive mode is combining defaults with user settings. Nested defaults that the user did not set are kept:

json defaults = {{"log", {{"level", "info"}, {"file", "app.log"}}}, {"retries", 3}};
json user_settings = {{"log", {{"level", "debug"}}}};

json config = defaults;
config.update(user_settings, true);
// {"log":{"file":"app.log","level":"debug"},"retries":3}

JSON Merge Patch (RFC 7396) also merges objects recursively, but it is a different tool: a #!json null in the patch means "remove this key". It is meant for applying merge patch documents (e.g., received via HTTP PATCH). To merge configuration-like objects, use #!cpp update(..., true). To apply a sequence of well-defined edit operations, see JSON Patch.

Removing elements

Elements are removed with erase, which accepts an object key, an array index, or an iterator. clear empties a value while keeping its type, and operator[] combined with assignment can overwrite a value entirely.

json j = {{"a", 1}, {"b", 2}, {"c", 3}};
j.erase("b");           // {"a":1,"c":3}

json a = {1, 2, 3, 4};
a.erase(1);             // [1,3,4]  (erase by index)

Editing a document

The operations above work on a basic_json value. A JSON text that was parsed into a document can also be changed in place, without building a basic_json tree for the parts that are not touched: set replaces a value, adds or replaces an object member, or replaces an array element (also through a JSON pointer), push_back appends to an array, insert inserts into an array (unlike basic_json::insert, it has no object overload; members are added with set), and erase removes a member or an element. These functions are available on the editable document types, such as json_editable_document.

See also

• push_back / emplace_back - append to an array
• emplace - insert into an object if the key is absent
• update - merge objects (shallow, or recursive with merge_objects)
• merge_patch - apply an RFC 7396 merge patch
• erase / clear - remove elements
• JSON Patch and Diff and JSON Merge Patch - structured modifications
• Editing a document - change a parsed document in place