How Can We Help?

# Comparison Operators

## Introduction to JavaScript comparison operators

To compare two values, you use a comparison operator. The following table shows the comparison operators in JavaScript:

Operator Meaning
< less than
> greater than
<= less than or equal to
>= greater than or equal to
== equal to
!= not equal to

A comparison operator returns a Boolean value indicating whether the comparison is true or not. See the following example:

``````let r1 = 20 > 10;// true
let r2 = 20 < 10;// false
let r3 = 10 == 10;// true
`````` A comparison operator takes two values. If the types of values are not comparable, the comparison operator converts them into values of comparable types according to specific rules.

### Compare numbers

If values are numbers, the comparison operators perform a numeric comparison. For example:

``````let a = 10,
b = 20;

console.log(a >= b);// false
console.log(a == 10);// true
``````

This example is straightforward. The variable `a` is `10`, and `b` is `20`. The expression `a >= b` expression returns `false` and the expression `a == 10` expression returns `true`.

### Compare strings

If the operands are strings, JavaScript compares the character codes numerically one by one in the string.

``````let name1 = 'alice',
name2 = 'bob';

let result = name1 < name2;
console.log(result);// true
console.log(name1 == 'alice');// true
``````

Because JavaScript compares the character codes in the strings numerically, you may receive an unexpected result, for example:

``````let f1 = 'apple',
f2 = 'Banana';
let result = f2 < f1;
console.log(result);// true
``````

In this example, `f2` is less than `f1` because the letter `B` has the character code `66` while the letter `a` has the character code `97`.

To fix this, you need to:

• First, convert the strings into a common format, either lowercase or uppercase
• Second, compare the converted values

For example:

``````let f1 = 'apple',
f2 = 'Banana';

let result = f2.toLowerCase() < f1.toLowerCase();
console.log(result);// false
``````

Note that the `toLowerCase()` is a method of the String object that converts the string to lowercase.

### Compare a number with a value of another type

If one value is a number and the other is not, the comparison operator will convert the non-numeric value into a number and compare them numerically. For example:

``````console.log(10 < '20');// true
``````

In this example, the comparison operator converts the string `'20'` into the number `20` and compares it with the number 10. Here is an example:

``````console.log(10 == '10');// true
``````

In this example, the comparison operator converts the string `'10'` into the number `10` and compares them numerically.

### Compare an object with a non-object

If a value is an object, the `valueOf()` method of that object is called to return the value for comparison. If the object doesn’t have the `valueOf()` method, the `toString()` method is called instead. For example:

``````let apple = {
valueOf: function () {
return 10;
},
};

let orange = {
toString: function () {
return '20';
},
};
console.log(apple > 10);// falseconsole.log(orange == 20);// true
``````

In this first comparison, the `apple` object has the `valueOf()` method that returns `10`. Therefore, the comparison operator uses the number 10 for comparison.

In the second comparison, JavaScript first calls the `valueOf()` method. However, the `orange` object doesn’t have the `valueOf()` method. So JavaScript calls the `toString()` method to get the returned value of `20` for comparison.

### Compare a Boolean with another value

If a value is a Boolean value, JavaScript converts it to a number and compares the converted value with the other value; `true` is converted to `1`, and `false` is converted to `0`. For example:

``````console.log(true > 0);// true
console.log(false < 1);// true
console.log(true > false);// true
console.log(false > true);// false
console.log(true >= true);// true
console.log(true <= true);// true
console.log(false <= false);// true
console.log(false >= false);// true
``````

In addition to the above rules, the equal (`==`) and not-equal(`!=`) operators also have the following rules.

### Compare `null` and `undefined`

In JavaScript, `null` equals `undefined`. It means that the following expression returns `true`.

``````console.log(null == undefined);// true
``````

### Compare `NaN` with other values

If either value is `NaN`, then the equal operator(`==`) returns `false`.

``````console.log(NaN == 1);// false
``````

Even

``````console.log(NaN == NaN);// false
``````

The not-equal (`!=`) operator returns `true` when comparing the `NaN` with another value:

``````console.log(NaN != 1);// true
``````

And also

``````console.log(NaN != NaN);// true
``````

## Strict equal (`===`) and not strict equal (`!==`)

Besides the comparison operators above, JavaScript provides the strict equal ( `===`) and not strict equal  ( `!==`) operators.

Operator Meaning
=== strict equal
!== not strict equal

The strict equal and not strict equal operators behave like the equal and not equal operators except that they don’t convert the operand before comparison. See the following example:

``````console.log("10" == 10);// true
console.log("10" === 10);// false
``````

In the first comparison, since we use the equality operator, JavaScript converts the string into a number and performs the comparison.

However, in the second comparison, we use the strict equal operator ( `===`), JavaScript doesn’t convert the string before comparison, therefore the result is `false`.

In this tutorial, you have learned how to use the JavaScript comparison operators to compare values.