Less than (<)

The less than (<) operator returns true if the left operand is less than the right operand, and false otherwise.

Syntax

x < y

Description

The operands are compared with multiple rounds of coercion, which can be summarized as follows:

First, objects are converted to primitives by calling its [@@toPrimitive]() (with "number" as hint), valueOf(), and toString() methods, in that order. The left operand is always coerced before the right one. Note that although [@@toPrimitive]() is called with the "number" hint (meaning there's a slight preference for the object to become a number), the return value is not converted to a number, since strings are still specially handled.
If both values are strings, they are compared as strings, based on the values of the Unicode code points they contain.
Otherwise JavaScript attempts to convert non-numeric types to numeric values:
- Boolean values true and false are converted to 1 and 0 respectively.
- null is converted to 0.
- undefined is converted to NaN.
- Strings are converted based on the values they contain, and are converted as NaN if they do not contain numeric values.
If either value is NaN, the operator returns false.
Otherwise the values are compared as numeric values. BigInt and number values can be compared together.

Other operators, including >, >=, and <=, use the same algorithm as <. There are two cases where all four operators return false:

If one of the operands gets converted to a BigInt, while the other gets converted to a string that cannot be converted to a BigInt value (it throws a syntax error when passed to BigInt()).
If one of the operands gets converted to NaN. (For example, strings that cannot be converted to numbers, or undefined.)

For all other cases, the four operators have the following relationships:

x < y === !(x >= y);
x <= y === !(x > y);
x > y === y < x;
x >= y === y <= x;

Note: One observable difference between < and > is the order of coercion, especially if the coercion to primitive has side effects. All comparison operators coerce the left operand before the right operand.

Examples

String to string comparison

"a" < "b"; // true
"a" < "a"; // false
"a" < "3"; // false

String to number comparison

"5" < 3; // false
"3" < 3; // false
"3" < 5; // true

"hello" < 5; // false
5 < "hello"; // false

"5" < 3n; // false
"3" < 5n; // true

Number to Number comparison

5 < 3; // false
3 < 3; // false
3 < 5; // true

Number to BigInt comparison

5n < 3; // false
3 < 5n; // true

Comparing Boolean, null, undefined, NaN

true < false; // false
false < true; // true

0 < true; // true
true < 1; // false

null < 0; // false
null < 1; // true

undefined < 3; // false
3 < undefined; // false

3 < NaN; // false
NaN < 3; // false

Comparison with side effects

Comparisons always coerce their operands to primitives. This means the same object may end up having different values within one comparison expression. For example, you may have two values that are both greater than and less than the other.

class Mystery {
  static #coercionCount = -1;
  valueOf() {
    Mystery.#coercionCount++;
    // The left operand is coerced first, so this will return 0
    // Then it returns 1 for the right operand
    return Mystery.#coercionCount % 2;
  }
}

const l = new Mystery();
const r = new Mystery();
console.log(l < r && r < l);
// true

Warning: This can be a source of confusion. If your objects provide custom primitive conversion logic, make sure it is idempotent: multiple coercions should return the same value.