JSON for Modern C++  3.7.2

◆ value() [4/4]

template<template< typename U, typename V, typename... Args > class ObjectType = std::map, template< typename U, typename... Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator, template< typename T, typename SFINAE=void > class JSONSerializer = adl_serializer>
template<class ValueType , typename std::enable_if< std::is_convertible< basic_json_t, ValueType >::value, int >::type = 0>
ValueType nlohmann::basic_json::value ( const typename object_t::key_type &  key,
const ValueType &  default_value 
) const

Returns either a copy of an object's element at the specified key key or a given default value if no element with key key exists.

The function is basically equivalent to executing

try {
return at(key);
} catch(out_of_range) {
return default_value;
Unlike at(const typename object_t::key_type&), this function does not throw if the given key key was not found.
Unlike operator[](const typename object_t::key_type& key), this function does not implicitly add an element to the position defined by key. This function is furthermore also applicable to const objects.
[in]keykey of the element to access
[in]default_valuethe value to return if key is not found
Template Parameters
ValueTypetype compatible to JSON values, for instance int for JSON integer numbers, bool for JSON booleans, or std::vector types for JSON arrays. Note the type of the expected value at key and the default value default_value must be compatible.
copy of the element at key key or default_value if key is not found
type_error.302if default_value does not match the type of the value at key
type_error.306if the JSON value is not an object; in that case, using value() with a key makes no sense.
Logarithmic in the size of the container.
The example below shows how object elements can be queried with a default value.
1 #include <iostream>
2 #include <nlohmann/json.hpp>
4 using json = nlohmann::json;
6 int main()
7 {
8  // create a JSON object with different entry types
9  json j =
10  {
11  {"integer", 1},
12  {"floating", 42.23},
13  {"string", "hello world"},
14  {"boolean", true},
15  {"object", {{"key1", 1}, {"key2", 2}}},
16  {"array", {1, 2, 3}}
17  };
19  // access existing values
20  int v_integer = j.value("integer", 0);
21  double v_floating = j.value("floating", 47.11);
23  // access nonexisting values and rely on default value
24  std::string v_string = j.value("nonexisting", "oops");
25  bool v_boolean = j.value("nonexisting", false);
27  // output values
28  std::cout << std::boolalpha << v_integer << " " << v_floating
29  << " " << v_string << " " << v_boolean << "\n";
30 }

Output (play with this example online):
1 42.23 oops false
The example code above can be translated with
g++ -std=c++11 -Isingle_include doc/examples/basic_json__value.cpp -o basic_json__value 
See also
at(const typename object_t::key_type&) for access by reference with range checking
operator[](const typename object_t::key_type&) for unchecked access by reference
version 1.0.0

Definition at line 18015 of file json.hpp.

reference at(size_type idx)
access specified array element with bounds checking
Definition: json.hpp:17521
detail::out_of_range out_of_range
exception indicating access out of the defined range
Definition: json.hpp:14782
basic_json<> json
default JSON class
Definition: json.hpp:2445