> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# JavaScript Less Than Or Equal To
The less than or equal to operator (`<=`) is a binary relational operator that evaluates whether the left operand is less than or equal to the right operand. Internally, JavaScript evaluates `x <= y` by performing the Abstract Relational Comparison `y < x` and negating the boolean result (`!(y < x)`). If the underlying comparison evaluates to `undefined` (which occurs when either operand coerces to `NaN`), the `<=` operator explicitly returns `false`.
```javascript theme={"dark"}
leftOperand <= rightOperand
```
## Evaluation Mechanics
When the JavaScript engine evaluates the `<=` operator, it executes the **Abstract Relational Comparison** algorithm. The process follows strict type coercion rules:
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
Because of implicit type coercion and the inverse evaluation model (`!(y < x)`), the operator exhibits specific behaviors depending on the operand types:
```javascript theme={"dark"}
// 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
The operator handles IEEE 754 special numeric values and BigInts according to specific rules:
* **`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`.
```javascript theme={"dark"}
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
```
Tired of Poor JavaScript Skills? Fix That With Deep Grasping!
Learn More
