> ## 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.
# TypeScript Greater Than
The `>` (greater than) operator is a relational binary operator that evaluates whether its left operand is strictly greater than its right operand, returning a boolean value (`true` or `false`).
```typescript theme={"dark"}
leftOperand > rightOperand
```
In TypeScript, the `>` operator applies strict compile-time type checking to restrict the unpredictable implicit type coercion (Abstract Relational Comparison) that occurs in standard JavaScript.
## Type Compatibility Rules
TypeScript requires operands to be of compatible, comparable types. The compiler permits the `>` operator for the following types:
1. **Numeric Types (`number`, `bigint`)**: Evaluates the algebraic magnitude. TypeScript explicitly allows cross-type relational comparisons between `number` and `bigint`. Comparisons involving `NaN` always evaluate to `false`.
2. **String Types (`string`)**: Evaluates lexicographically based on the sequence of 16-bit unsigned integer values (UTF-16 code units).
3. **Enums (Numeric and String)**: Numeric enums are compared by their underlying numeric values. String enums are assignable to the `string` type and are compared lexicographically.
4. **Date Objects (`Date`)**: Evaluates based on their underlying numeric time value (milliseconds since the epoch) via the internal `valueOf()` method.
```typescript theme={"dark"}
// Valid syntax and type comparisons
const numCheck: boolean = 10 > 5; // true
const bigIntCheck: boolean = 10n > 5n; // true
const mixedNumCheck: boolean = 10 > 5n; // true (number > bigint is allowed)
const strCheck: boolean = "Z" > "A"; // true
enum StringEnum { A = "A", B = "B" }
const strEnumCheck: boolean = StringEnum.B > StringEnum.A; // true
const dateCheck: boolean = new Date("2024-02-01") > new Date("2024-01-01"); // true
```
## Compiler Errors
If you attempt to use the `>` operator on incompatible types, TypeScript will throw a compile-time error (`TS2365`). While `number` and `bigint` can be mixed, TypeScript intentionally blocks all other cross-type comparisons (e.g., `number > string`). It also strictly blocks comparisons between booleans, arrays, and complex objects (excluding `Date`), unless explicitly bypassed using the `any` type.
```typescript theme={"dark"}
// TS2365: Operator '>' cannot be applied to types 'number' and 'string'.
const invalidMixed = 10 > "5";
// TS2365: Operator '>' cannot be applied to types 'boolean' and 'boolean'.
const invalidBool = true > false;
// TS2365: Operator '>' cannot be applied to types 'number[]' and 'number[]'.
const invalidArray = [1, 2] > [1];
```
## Bypassing Type Checks
If operands are typed as `any`, TypeScript defers to the JavaScript runtime behavior. The JavaScript engine will attempt to coerce the operands into primitives (preferring numbers) using the internal `ToPrimitive` and `ToNumeric` abstract operations before performing the comparison.
```typescript theme={"dark"}
const left: any = [2];
const right: any = 1;
// Compiles successfully due to 'any'.
// At runtime, [2] is coerced to "2", then to 2. 2 > 1 evaluates to true.
const bypassedCheck: boolean = left > right;
```
Tired of Poor TypeScript Skills? Fix That With Deep Grasping!
Learn More
