Skip to content

# nlohmann::basic_json::value_t

    enum class value_t : std::uint8_t {
        null,
        object,
        array,
        string,
        boolean,
        number_integer,
        number_unsigned,
        number_float,
        binary,
        discarded
    };

This enumeration collects the different JSON types. It is internally used to distinguish the stored values, and the functions `is_null`, `is_object`, `is_array`, `is_string`, `is_boolean`, `is_number` (with `is_number_integer`, `is_number_unsigned`, and `is_number_float`), `is_discarded`, `is_binary`, `is_primitive`, and `is_structured` rely on it.

## Notes

Ordering

The order of types is as follows:

1. `null`
2. `boolean`
3. `number_integer`, `number_unsigned`, `number_float`
4. `object`
5. `array`
6. `string`
7. `binary`

`discarded` is unordered.

Types of numbers

There are three enumerators for numbers (`number_integer`, `number_unsigned`, and `number_float`) to distinguish between different types of numbers:

- `number_unsigned_t` for unsigned integers
- `number_integer_t` for signed integers
- `number_float_t` for floating-point numbers or to approximate integers which do not fit into the limits of their respective type

Comparison operators

`operator<` and `operator<=>` (since C++20) are overloaded and compare according to the ordering described above. Until C++20 all other relational and equality operators yield results according to the integer value of each enumerator. Since C++20 some compilers consider the rewritten candidates generated from `operator<=>` during overload resolution, while others do not. For predictable and portable behavior use:

- `operator<` or `operator<=>` when wanting to compare according to the order described above
- `operator==` or `operator!=` when wanting to compare according to each enumerators integer value

## Examples

Example

The following code how `type()` queries the `value_t` for all JSON types.

    #include <iostream>
    #include <nlohmann/json.hpp>

    using json = nlohmann::json;

    int main()
    {
        // create JSON values
        json j_null;
        json j_boolean = true;
        json j_number_integer = -17;
        json j_number_unsigned = 42u;
        json j_number_float = 23.42;
        json j_object = {{"one", 1}, {"two", 2}};
        json j_array = {1, 2, 4, 8, 16};
        json j_string = "Hello, world";

        // call type()
        std::cout << std::boolalpha;
        std::cout << (j_null.type() == json::value_t::null) << '\n';
        std::cout << (j_boolean.type() == json::value_t::boolean) << '\n';
        std::cout << (j_number_integer.type() == json::value_t::number_integer) << '\n';
        std::cout << (j_number_unsigned.type() == json::value_t::number_unsigned) << '\n';
        std::cout << (j_number_float.type() == json::value_t::number_float) << '\n';
        std::cout << (j_object.type() == json::value_t::object) << '\n';
        std::cout << (j_array.type() == json::value_t::array) << '\n';
        std::cout << (j_string.type() == json::value_t::string) << '\n';
    }

Output:

    true
    true
    true
    true
    true
    true
    true
    true

## Version history

- Added in version 1.0.0.
- Added unsigned integer type in version 2.0.0.
- Added binary type in version 3.8.0.

Last update: May 29, 2022
Back to top