// (1) bool contains(const typename object_t::key_type& key) const; // (2) template<typename KeyType> bool contains(KeyType&& key) const; // (3) bool contains(const json_pointer& ptr) const; // (4) template<typename T> bool contains(T) const = delete;
key. If the element is not found or the JSON value is not an object, #!cpp false is returned.KeyType is comparable with #!cpp typename object_t::key_type and #!cpp typename object_comparator_t::is_transparent denotes a type.ptr can be resolved in the current JSON value.T is an integral type and is declared as deleted, so that a call with an integer key (for example, #!cpp j.contains(0)) fails to compile. Otherwise, the integer literal 0 would convert to a null #!cpp const char* and, from there, to the key type, causing undefined behavior at runtime.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).
key (in) : key value to check its existence.
ptr (in) : JSON pointer to check its existence.
#!cpp true if an element with specified key exists. If no such element with such a key is found or the JSON value is not an object, #!cpp false is returned.#!cpp true if the JSON pointer can be resolved to a stored value, #!cpp false otherwise.Strong exception safety: if an exception occurs, the original value stays intact.
Logarithmic in the size of the JSON object.
#!cpp false when executed on a JSON type that is not an object.#!cpp contains(0)) does not compile: such an argument would otherwise implicitly convert to a null #!cpp const char* and, from there, cause undefined behavior when constructing a #!cpp std::string for the object key. To check for an array element instead, use at, operator[], or compare against size.!!! info “Postconditions”
If `#!cpp j.contains(x)` returns `#!c true` for a key or JSON pointer `x`, then it is safe to call `j[x]`.
!!! warning “Deprecation”
Overload (3) 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.
??? example “Example: (1) check with key”
The example shows how `contains()` is used. ```cpp --8<-- "examples/contains__object_t_key_type.cpp" ``` Output: ```json --8<-- "examples/contains__object_t_key_type.output" ```
??? example “Example: (2) check with key using string_view”
The example shows how `contains()` is used. ```cpp --8<-- "examples/contains__keytype.c++17.cpp" ``` Output: ```json --8<-- "examples/contains__keytype.c++17.output" ```
??? example “Example: (3) check with JSON pointer”
The example shows how `contains()` is used. ```cpp --8<-- "examples/contains__json_pointer.cpp" ``` Output: ```json --8<-- "examples/contains__json_pointer.output" ```
KeyType to support comparable types in version 3.11.0. Support for keys convertible to std::string_view added in version 3.13.0, consistently across the lookup functions.