> ## 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 Greater Than
The greater than (`>`) operator is a binary relational operator that evaluates whether its left operand is strictly greater than its right operand, returning a boolean (`true` or `false`).
```javascript theme={"dark"}
leftOperand > rightOperand
```
When evaluating the expression, JavaScript engine applies the **Abstract Relational Comparison** algorithm. This process dictates how different data types are coerced and compared:
1. **Primitive Conversion (`ToPrimitive`)**: Both operands are converted to primitive values. If an operand is an object, JavaScript attempts to convert it by calling its `valueOf()` and `toString()` methods, prioritizing numeric conversion.
2. **String Comparison**: If both resulting primitives are strings, they are compared lexicographically based on their UTF-16 code unit values.
3. **Numeric Conversion (`ToNumeric`)**: If at least one of the primitives is not a string, both operands are coerced into numeric values (either `Number` or `BigInt`).
4. **`NaN` Evaluation**: If either operand coerces to `NaN` (Not-a-Number), the operator strictly returns `false`.
5. **Zero Evaluation**: JavaScript treats `+0` and `-0` as mathematically equal; neither is greater than the other.
## Mechanical Examples
**Strict Numeric Comparison**
Compares standard IEEE 754 double-precision floats or BigInts.
```javascript theme={"dark"}
5 > 3; // true
-1 > 0; // false
10n > 9; // true (BigInt and Number can be compared safely)
```
**Lexicographical String Comparison**
Compares UTF-16 code units from left to right.
```javascript theme={"dark"}
"b" > "a"; // true (98 > 97)
"Z" > "a"; // false (90 > 97 - uppercase letters have lower code units)
"10" > "2"; // false (Compares "1" and "2", 49 > 50 is false)
```
**Type Coercion (Mixed Types)**
Forces numeric conversion when types do not match.
```javascript theme={"dark"}
"5" > 3; // true (String "5" coerces to Number 5)
true > false;// true (Boolean true coerces to 1, false to 0)
null > -1; // true (null coerces to 0)
```
**Object Coercion**
Objects are reduced to primitives before comparison.
```javascript theme={"dark"}
[5] > 4; // true (Array [5] coerces to String "5", then Number 5)
["a"] > 0; // false (Array ["a"] coerces to "a", then NaN. NaN > 0 is false)
```
**NaN Handling**
Any comparison involving `NaN` yields `false`.
```javascript theme={"dark"}
NaN > 5; // false
5 > NaN; // false
NaN > NaN; // false
undefined > 0; // false (undefined coerces to NaN)
```
Tired of Poor JavaScript Skills? Fix That With Deep Grasping!
Learn More
