== vs === in JavaScript

Strict equality compares both the type and the value, and it never converts anything. Loose equality converts one or both of the values to a common type first, and then compares them. The two operators run at about the same speed, and that is not the reason to pick one of them. The strict operator is easy to predict, while the loose one asks you to remember a conversion table every time you read it.

console.log(1 == '1');          // true - the text becomes a number
console.log(1 === '1');         // false - the types are different
console.log(0 == '');           // true - both become 0
console.log(0 === '');          // false
console.log(null == undefined); // true - this is a special rule
console.log(null === undefined); // false
console.log(NaN == NaN);        // false
console.log([] == false);       // true - the array becomes '' and then 0

The loose operator has a defined conversion order, and it is worth memorising for the one or two places where you will meet it. If both values already have the same type, it behaves like strict equality. If one of them is null and the other is a value that was never assigned, they are equal. Otherwise the engine turns the value that is not an object into a number and compares the numbers. That last step explains the strange results. An empty array becomes an empty string, which becomes zero, and the text "false" becomes a number, which is not a number at all, so that comparison is false.

Strict equality avoids all of that because it never converts. A number is never equal to a text that happens to spell the same digits, and two different objects are never equal to each other no matter how similar they look.

The exception worth knowing is that strict equality still uses object identity for objects and arrays. Two separately created empty arrays are not equal, even though both of them have no elements at all.

There is exactly one idiom that most senior engineers accept, which is comparing against null with the double equals. The expression value == null is true when the value is null, and it is also true when the value was never assigned, and it is false for everything else.

That works because the loose operator has a special rule for null. It is equal to null and to a value that was never assigned, and to nothing else. No numeric conversion happens on that path, so unlike the general case there is no surprising coercion to worry about.

It is worth being precise about why this is not the same as the double-bar form. The double-bar version is not an alias for it. A value that was never assigned is equal to that one, but null is not, because null becomes zero while the missing value becomes a number that is not a number, and zero is never equal to a number that is not a number. Depending on how well you remember the rules, people reach for the wrong one and end up with a null value that quietly fails the check.

Beyond that one case, the guidance is to use strict equality everywhere and to convert explicitly when the types might be different. If you are comparing a form field against a number, write Number(value) === 42, or use a type guard, and make the conversion visible to the reader.

Two more points are worth adding to a full answer. Some style guides ban the loose operator completely and require an explicit check for null plus a separate check for a missing value. That is more verbose, but it removes any reliance on a subtle rule. And in a codebase that uses TypeScript, the compiler usually pushes you towards the strict operator anyway, because the type system decides what needs comparing in the first place.