JavaScript Tutorial
Comparison operators help you decide if two values are equal, greater, or less than each other.
They are the backbone of conditionals, filters, validation rules, and sorting logic.
Small comparison mistakes can flip logic or let invalid data through. That is why strict equality and clear comparisons matter.
Understanding how JavaScript compares values keeps your conditions predictable and safe.
a == b // loose equality
a === b // strict equality
a != b // loose inequality
a !== b // strict inequality
a > b, a < b, a >= b, a <= bconsole.log(5 == "5"); // true
console.log(5 === "5"); // false
console.log(0 == false); // true
console.log(0 === false); // falseStrict equality avoids type coercion and is safer for most comparisons.
console.log(10 > 7); // true
console.log(10 <= 7); // false
console.log("b" > "a"); // true (lexicographic)Relational operators compare numeric values and also work with strings.
`==` allows type coercion, while `===` compares both value and type. Most codebases prefer strict equality to avoid surprises.
Loose equality has edge cases like `0 == false` or `"" == false`, which can introduce subtle bugs.
Relational operators like `>`, `<`, `>=`, and `<=` compare numeric values and also work with strings by lexicographic order.
Be careful when comparing strings that look like numbers. Convert explicitly if needed.
`NaN` is never equal to itself; use `Number.isNaN()` or `Object.is()` to check it.
`null` and `undefined` are only loosely equal to each other; strict equality keeps them distinct.
Comparisons appear in array filtering, sorting, and searching. Your comparisons determine what users see first.
Use comparators that return consistent results to avoid unstable sorting behaviors.
const value = NaN;
console.log(value === NaN); // false
console.log(Number.isNaN(value)); // true
console.log(Object.is(value, NaN)); // trueUse Number.isNaN or Object.is to safely compare NaN.
const scores = [12, 4, 18, 6];
scores.sort((a, b) => a - b);
console.log(scores); // [4, 6, 12, 18]Comparators rely on consistent comparison results for correct sorting.
Without
console.log(0 == false); // true
console.log("" == false); // trueWith
console.log(0 === false); // false
console.log("" === false); // falsePrefer === to avoid coercion surprises.
Use Number.isNaN or Object.is for NaN checks.
Convert strings to numbers before comparison.
Use strict equality to keep them distinct.
It avoids implicit type coercion and makes comparisons predictable.
Use Number.isNaN or Object.is because NaN !== NaN.
Object equality compares references, not deep values.
Practice: Write a function that checks if a user is an adult and the score is in range using comparisons.
const age = 17;
const score = 92;
// TODO: print true only if age >= 18 and score between 80 and 100
One Possible Solution
const age = 17;
const score = 92;
const ok = age >= 18 && score >= 80 && score <= 100;
console.log(ok);`==` coerces types before comparing; `===` compares both value and type.
NaN represents an invalid number, and by specification it is not equal to anything, including itself.
Yes, but it compares references. Two different objects with the same contents are not equal.
JavaScript compares strings lexicographically based on Unicode code points.
Try the comparisons in the compiler and see how == and === behave.