// until C++20 bool operator<=(const_reference lhs, const_reference rhs) noexcept; // (1) template<typename ScalarType> bool operator<=(const_reference lhs, const ScalarType rhs) noexcept(/* see below */); // (2) template<typename ScalarType> bool operator<=(ScalarType lhs, const const_reference rhs) noexcept(/* see below */); // (2)
Compares whether one JSON value lhs is less than or equal to another JSON value rhs according to the following rules:
#!cpp false if (1) either operand is discarded, or (2) either operand is NaN and the other operand is either NaN or any other number.#!cpp !(rhs < lhs) (see operator<).Compares whether a JSON value is less than or equal to a scalar or a scalar is less than or equal to a JSON value by converting the scalar to a JSON value and comparing both JSON values according to 1.
ScalarType : a scalar type according to std::is_scalar<ScalarType>::value
lhs (in) : first value to consider
rhs (in) : second value to consider
whether lhs is less than or equal to rhs
#!cpp nullptr; the function is #!cpp noexcept exactly in that case. Otherwise, it throws what the conversion throws, for example std::bad_alloc when converting a string, or out_of_range.410 for an enum value not mapped by NLOHMANN_JSON_SERIALIZE_ENUM_STRICT.Linear.
!!! note “Comparing NaN”
`NaN` values are unordered within the domain of numbers. The following comparisons all yield `#!cpp false`: 1. Comparing a `NaN` with itself. 2. Comparing a `NaN` with another `NaN`. 3. Comparing a `NaN` and any other number.
!!! note “Operator overload resolution”
Since C++20 overload resolution will consider the _rewritten candidate_ generated from [`operator<=>`](operator_spaceship.md).
!!! warning “Deprecation”
If [`JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](../macros/json_use_legacy_discarded_value_comparison.md) is defined to `1`, the library declares a member `#!cpp bool operator<=(const_reference rhs) const noexcept` in C++20 mode to emulate the legacy comparison of discarded values. This member is deprecated since version 3.11.0, together with the legacy comparison behavior. See the [migration guide](../../integration/migration_guide.md#miscellaneous-functions) for how to update existing code.
??? example
The example demonstrates comparing several JSON types.
```cpp
#include <iostream>
#include <nlohmann/json.hpp>
using json = nlohmann::json;
int main()
{
// create several JSON values
json array_1 = {1, 2, 3};
json array_2 = {1, 2, 4};
json object_1 = {{"A", "a"}, {"B", "b"}};
json object_2 = {{"B", "b"}, {"A", "a"}};
json number_1 = 17;
json number_2 = 17.0000000000001L;
json string_1 = "foo";
json string_2 = "bar";
// output values and comparisons
std::cout << std::boolalpha;
std::cout << array_1 << " <= " << array_2 << " " << (array_1 <= array_2) << '\n';
std::cout << object_1 << " <= " << object_2 << " " << (object_1 <= object_2) << '\n';
std::cout << number_1 << " <= " << number_2 << " " << (number_1 <= number_2) << '\n';
std::cout << string_1 << " <= " << string_2 << " " << (string_1 <= string_2) << '\n';
}
```
Output:
```json
[1,2,3] <= [1,2,4] true
{"A":"a","B":"b"} <= {"A":"a","B":"b"} true
17 <= 17.0000000000001 true
"foo" <= "bar" false
```
#!cpp noexcept in version 3.13.0; before, a throwing conversion called std::terminate.