basic_json::operator==¶
bool operator==(const_reference lhs, const_reference rhs) noexcept;
template<typename ScalarType>
bool operator==(const_reference lhs, const ScalarType rhs) noexcept;
template<typename ScalarType>
bool operator==(ScalarType lhs, const const_reference rhs) noexcept;
Compares two JSON values for equality according to the following rules:
- Two JSON values are equal if (1) they are not discarded, (2) they are from the same type, and (3) their stored values are the same according to their respective
operator==
. - Integer and floating-point numbers are automatically converted before comparison. Note that two NaN values are always treated as unequal.
Template parameters¶
ScalarType
- a scalar type according to
std::is_scalar<ScalarType>::value
Parameters¶
lhs
(in)- first value to consider
rhs
(in)- second value to consider
Return value¶
whether the values lhs
and rhs
are equal
Exception safety¶
No-throw guarantee: this function never throws exceptions.
Complexity¶
Linear.
Notes¶
Note
- NaN values never compare equal to themselves or to other NaN values.
- JSON
null
values are all equal. - Discarded values never compare equal to themselves.
Note
Floating-point numbers inside JSON values numbers are compared with json::number_float_t::operator==
which is double::operator==
by default. To compare floating-point while respecting an epsilon, an alternative comparison function could be used, for instance
template<typename T, typename = typename std::enable_if<std::is_floating_point<T>::value, T>::type>
inline bool is_same(T a, T b, T epsilon = std::numeric_limits<T>::epsilon()) noexcept
{
return std::abs(a - b) <= epsilon;
}
Or you can self-defined operator equal function like this:
bool my_equal(const_reference lhs, const_reference rhs)
{
const auto lhs_type lhs.type();
const auto rhs_type rhs.type();
if (lhs_type == rhs_type)
{
switch(lhs_type)
// self_defined case
case value_t::number_float:
return std::abs(lhs - rhs) <= std::numeric_limits<float>::epsilon();
// other cases remain the same with the original
...
}
...
}
Example¶
Example
The example demonstrates comparing several JSON types.
#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.000000000000001L;
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:
[1,2,3] == [1,2,4] false
{"A":"a","B":"b"} == {"A":"a","B":"b"} true
17 == 17.0 true
"foo" == "bar" false
Version history¶
- Added in version 1.0.0.