json/docs/mkdocs/docs/api/basic_json/at.md

nlohmann::basic_json::at

// (1)
reference at(size_type idx);
const_reference at(size_type idx) const;

// (2)
reference at(const typename object_t::key_type& key);
const_reference at(const typename object_t::key_type& key) const;

// (3)
template<typename KeyType>
reference at(KeyType&& key);
template<typename KeyType>
const_reference at(KeyType&& key) const;

// (4)
reference at(const json_pointer& ptr);
const_reference at(const json_pointer& ptr) const;

1. Returns a reference to the array element at specified location idx, with bounds checking.
2. Returns a reference to the object element with specified key key, with bounds checking.
3. See 2. This overload is only available if KeyType is comparable with #!cpp typename object_t::key_type and #!cpp typename object_comparator_t::is_transparent denotes a type.
4. Returns a reference to the element at specified JSON pointer ptr, with bounds checking.

Template parameters

KeyType

A type for an object key other than json_pointer that is comparable with string_t using object_comparator_t. This can also be a string view (C++17).

Parameters

idx (in)

index of the element to access

key (in)

object key of the elements to access

ptr (in)

JSON pointer to the desired element

Return value

1. reference to the element at index idx
2. reference to the element at key key
3. reference to the element at key key
4. reference to the element pointed to by ptr

Exception safety

Strong exception safety: if an exception occurs, the original value stays intact.

Exceptions

1. The function can throw the following exceptions:
   • Throws type_error.304 if the JSON value is not an array; in this case, calling at with an index makes no sense. See the example below.
   • Throws out_of_range.401 if the index idx is out of range of the array; that is, idx >= size(). See the example below.
2. The function can throw the following exceptions:
   • Throws type_error.304 if the JSON value is not an object; in this case, calling at with a key makes no sense. See the example below.
   • Throws out_of_range.403 if the key key is not stored in the object; that is, find(key) == end(). See the example below.
3. See 2.
4. The function can throw the following exceptions:
   • Throws parse_error.106 if an array index in the passed JSON pointer ptr begins with '0'. See the example below.
   • Throws parse_error.109 if an array index in the passed JSON pointer ptr is not a number. See the example below.
   • Throws out_of_range.401 if an array index in the passed JSON pointer ptr is out of range. See the example below.
   • Throws out_of_range.402 if the array index '-' is used in the passed JSON pointer ptr. As at provides checked access (and no elements are implicitly inserted), the index '-' is always invalid. See the example below.
   • Throws out_of_range.403 if the JSON pointer describes a key of an object which cannot be found. See the example below.
   • Throws out_of_range.404 if the JSON pointer ptr can not be resolved. See the example below.
   • Throws out_of_range.410 if an array index in the passed JSON pointer ptr exceeds the range of size_type (e.g., on 32-bit platforms).

Complexity

1. Constant.
2. Logarithmic in the size of the container.
3. Logarithmic in the size of the container.
4. Logarithmic in the size of the container.

Notes

!!! warning "Deprecation"

Overload (4) also accepts a [`json_pointer`](../json_pointer/index.md) whose template argument is a `basic_json`
specialization (e.g., `nlohmann::json_pointer<nlohmann::json>`) instead of a string type. This is deprecated since
version 3.11.0 and will be removed in a future major version; use `basic_json::json_pointer` (for `json`,
`nlohmann::json_pointer<std::string>`) instead.

You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
function.

See the [migration guide](../../integration/migration_guide.md#json-pointers) for how to update existing code.

Examples

??? example "Example: (1) access specified array element with bounds checking"

The example below shows how array elements can be read and written using `at()`. It also demonstrates the different
exceptions that can be thrown.

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

Output:

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

??? example "Example: (1) access specified array element with bounds checking"

The example below shows how array elements can be read using `at()`. It also demonstrates the different exceptions
that can be thrown.
    
```cpp
--8<-- "examples/at__size_type_const.cpp"
```

Output:

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

??? example "Example: (2) access specified object element with bounds checking"

The example below shows how object elements can be read and written using `at()`. It also demonstrates the different
exceptions that can be thrown.
    
```cpp
--8<-- "examples/at__object_t_key_type.cpp"
```

Output:

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

??? example "Example: (2) access specified object element with bounds checking"

The example below shows how object elements can be read using `at()`. It also demonstrates the different exceptions
that can be thrown.

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

Output:

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

??? example "Example: (3) access specified object element using string_view with bounds checking"

The example below shows how object elements can be read and written using `at()`. It also demonstrates the different
exceptions that can be thrown.

```cpp
--8<-- "examples/at__keytype.c++17.cpp"
```

Output:

```json
--8<-- "examples/at__keytype.c++17.output"
```

??? example "Example: (3) access specified object element using string_view with bounds checking"

The example below shows how object elements can be read using `at()`. It also demonstrates the different exceptions
that can be thrown.

```cpp
--8<-- "examples/at__keytype_const.c++17.cpp"
```

Output:

```json
--8<-- "examples/at__keytype_const.c++17.output"
```

??? example "Example: (4) access specified element via JSON Pointer"

The example below shows how object elements can be read and written using `at()`. It also demonstrates the different
exceptions that can be thrown.
    
```cpp
--8<-- "examples/at__json_pointer.cpp"
```

Output:

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

??? example "Example: (4) access specified element via JSON Pointer"

The example below shows how object elements can be read using `at()`. It also demonstrates the different exceptions
that can be thrown.
    
```cpp
--8<-- "examples/at__json_pointer_const.cpp"
```

Output:

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

See also

• documentation on checked access
• operator[] for unchecked access by reference
• value for access with default value

Version history

1. Added in version 1.0.0.
2. Added in version 1.0.0.
3. Added in version 3.11.0. Fixed in version 3.13.0 to consistently accept std::string_view-convertible keys, as already supported by operator[], value, find, and other lookup functions.
4. Added in version 2.0.0. Throws parse_error.109 instead of out_of_range.404 for a one-character array index that is not a digit (e.g., /x) in version 3.13.0, as it already did for longer ones.