JavaScript Less Than Or Equal To

leftOperand <= rightOperand

​

Evaluation Mechanics

1. ToPrimitive Conversion: Both operands are converted to primitive values. If an operand is an object, the engine first attempts to call its [Symbol.toPrimitive]() method. If this method is absent, it falls back to calling valueOf() and toString() in sequence until a primitive is yielded.
2. String Comparison: If both resulting primitives are strings, they are compared lexicographically based on their sequence of 16-bit unsigned integer values (UTF-16 code units).
3. String and BigInt Comparison: If one primitive is a String and the other is a BigInt, the string is converted directly to a BigInt via the StringToBigInt algorithm. This prevents the precision loss that would occur if a large numeric string were coerced to a standard Number.
4. Numeric Comparison: For all other type combinations where at least one primitive is not a string, both operands are coerced to numeric values (via the ToNumeric algorithm) and compared mathematically.

​

Type Coercion Behavior

// Standard numeric comparison
5 <= 5;       // true
10 <= 5;      // false

// Lexicographical string comparison
"apple" <= "banana"; // true (UTF-16 code unit for 'a' is less than 'b')
"10" <= "2";         // true (UTF-16 code unit for '1' is less than '2')

// Mixed types (String coerced to Number)
"10" <= 20;   // true (String "10" becomes Number 10)
"a" <= 5;     // false (String "a" becomes NaN)

// Booleans (Coerced to Number: true -> 1, false -> 0)
true <= 1;    // true
false <= 0;   // true

// Null and Undefined
// null <= 0 evaluates as !(0 < null). null coerces to 0, so 0 < 0 is false. !(false) is true.
null <= 0;      // true 
null < 0;       // false
null == 0;      // false

undefined <= 0; // false (undefined coerces to NaN)

​

Special Numeric Values

• NaN: Any relational comparison involving NaN evaluates to undefined internally, causing the <= operator to return false. This includes NaN <= NaN.
• Zero: +0 and -0 are considered mathematically equal.
• Infinity: +Infinity is greater than or equal to any number. -Infinity is less than or equal to any number.
• BigInt: BigInt and Number types can be compared directly without throwing a TypeError.

NaN <= 5;          // false
5 <= NaN;          // false
NaN <= NaN;        // false
-0 <= +0;          // true

// BigInt and Number comparison
10n <= 10;         // true 

// String and BigInt comparison (StringToBigInt preserves precision)
"9007199254740993" <= 9007199254740992n; // false