Numbers & Math

JavaScript's single number type, floating-point surprises, NaN, Infinity, the Math object, and BigInt.

What it is, in plain English: JavaScript has one number type for everything — whole numbers, decimals, negative numbers. Unlike Python, there's no separate int and float. All numbers are stored as 64-bit floating-point (IEEE 754), which means very large or very precise decimal numbers can have tiny rounding errors. NaN (Not a Number) and Infinity are special number values, not errors.

Numbers in JavaScript

JavaScript keeps things simple: there is exactly one number type. Whether you write 42 or 3.14 or -100, they're all the same type. No separate integers and floats like Python.

Basic arithmetic

console.log(5 + 3);    // 8    — addition
console.log(10 - 4);   // 6    — subtraction
console.log(6 * 7);    // 42   — multiplication
console.log(15 / 4);   // 3.75 — division (always gives decimal if needed)
console.log(15 % 4);   // 3    — remainder (what's left after dividing)
console.log(2 ** 8);   // 256  — exponent (2 to the power of 8)

The remainder operator % is worth knowing — it's how you check if a number is even (n % 2 === 0) or fits into a time period (seconds % 60 gives the leftover seconds).

The floating-point surprise

Here's something that surprises almost every beginner:

console.log(0.1 + 0.2);   // 0.30000000000000004

That's not a bug in your code. It's how all computers store decimal numbers — they use binary, and 0.1 can't be represented exactly in binary (like 1/3 can't be written exactly in decimal). The tiny rounding error is fundamental to how computers work.

The fix for display purposes:

let total = 0.1 + 0.2;
console.log(total.toFixed(2));   // "0.30" — rounds to 2 decimal places, returns a string
console.log(+total.toFixed(2));  // 0.3    — the + converts it back to a number

NaN — Not a Number

NaN is what JavaScript returns when a mathematical operation doesn't produce a valid number:

console.log("hello" * 2);    // NaN — can't multiply text
console.log(0 / 0);          // NaN
console.log(Math.sqrt(-1));   // NaN — no real square root of negative

// NaN is type "number" — which is confusing but true:
console.log(typeof NaN);     // "number"

// NaN is the only value not equal to itself:
console.log(NaN === NaN);    // false!

// Safe way to check for NaN:
console.log(Number.isNaN(NaN));        // true
console.log(Number.isNaN("hello"));    // false (it's a string, not NaN)

Infinity

console.log(1 / 0);           // Infinity
console.log(-1 / 0);          // -Infinity
console.log(Infinity + 1);    // Infinity
console.log(Number.isFinite(Infinity));  // false
console.log(Number.isFinite(42));        // true

The Math object — useful maths functions

Math is a built-in object with mathematical tools. You don't need to import anything — it's always available:

Math.round(4.5)    // 5  — round to nearest integer
Math.floor(4.9)    // 4  — always round down
Math.ceil(4.1)     // 5  — always round up
Math.abs(-7)       // 7  — absolute value (remove the minus sign)
Math.max(3, 7, 2)  // 7  — largest value
Math.min(3, 7, 2)  // 2  — smallest value
Math.pow(2, 10)    // 1024 — same as 2 ** 10
Math.sqrt(16)      // 4  — square root
Math.PI            // 3.141592653589793

// Random numbers:
Math.random()               // random decimal 0.0 to 0.9999...
Math.floor(Math.random() * 6) + 1  // random integer 1 to 6 (like a dice)

Converting strings to numbers

// User input always comes as a string — convert before calculating:
let userInput = "42";
console.log(userInput + 10);      // "4210" — string concatenation! Wrong.
console.log(Number(userInput) + 10);  // 52   — converted first

// parseInt and parseFloat:
parseInt("42px")      // 42  — stops at the first non-number character
parseFloat("3.14em")  // 3.14
parseInt("hello")     // NaN — no number to extract

Try It Yourself

// JavaScript has ONE number type — integers and decimals both
let whole = 42;
let decimal = 3.14;
let negative = -7;

console.log(typeof whole);    // "number"
console.log(typeof decimal);  // "number" — same type!

// Basic arithmetic
console.log(10 + 3);   // 13
console.log(10 - 3);   // 7
console.log(10 * 3);   // 30
console.log(10 / 3);   // 3.3333333333333335
console.log(10 % 3);   // 1  (remainder/modulo)
console.log(2 ** 10);  // 1024  (exponent — 2 to the power of 10)

// The floating-point surprise
console.log(0.1 + 0.2);          // 0.30000000000000004 — not 0.3!
console.log((0.1 + 0.2).toFixed(2)); // "0.30" — fix with toFixed()

// Special number values
console.log(10 / 0);    // Infinity
console.log(-10 / 0);   // -Infinity
console.log("abc" * 2); // NaN — Not a Number

// Math object
console.log(Math.round(4.6));  // 5
console.log(Math.floor(4.9));  // 4
console.log(Math.ceil(4.1));   // 5
console.log(Math.max(3, 7, 2)); // 7
console.log(Math.random());    // random 0.0–0.9999...

Number precision, safe integers, and numeric separators

IEEE 754 double-precision — the detail

JavaScript numbers are 64-bit IEEE 754 doubles: 1 sign bit, 11 exponent bits, 52 mantissa bits. This gives about 15–17 significant decimal digits of precision. The largest exact integer is 2⁵³−1 = Number.MAX_SAFE_INTEGER (9,007,199,254,740,991). Beyond this, integers lose precision:

Number.MAX_SAFE_INTEGER         // 9007199254740991
Number.MAX_SAFE_INTEGER + 1     // 9007199254740992  ✓
Number.MAX_SAFE_INTEGER + 2     // 9007199254740992  ✗ same! lost a bit

Number.isSafeInteger(9007199254740991)  // true
Number.isSafeInteger(9007199254740992)  // false (could be imprecise)

Numeric separators

ES2021 added underscores as separators for readability:

const million    = 1_000_000;
const hex        = 0xFF_EC_D5_12;
const binary     = 0b1010_0001;
const bigInteger = 9_007_199_254_740_991n;

Number methods

let n = 123.456789;

n.toFixed(2)         // "123.46"  — string, 2 decimal places
n.toPrecision(5)     // "123.46"  — string, 5 significant digits
n.toExponential(2)   // "1.23e+2" — string, scientific notation
n.toString(16)       // "7b.74bc6a7ef9db"  — hex string
n.toString(2)        // binary string
Number.isInteger(42)    // true
Number.isInteger(42.0)  // true (42.0 === 42 in JS)
Number.isInteger(42.1)  // false

Handling float precision properly

// For money — use integer cents internally:
const priceInCents = 1099;   // $10.99
const taxInCents   = 88;     // $0.88
const totalCents   = priceInCents + taxInCents;  // 1187
console.log(`$${(totalCents / 100).toFixed(2)}`);  // "$11.87"

// For comparison — use epsilon:
const a = 0.1 + 0.2;
const b = 0.3;
Math.abs(a - b) < Number.EPSILON   // true — "close enough to equal"

parseInt radix

// Always pass radix to parseInt — no surprises:
parseInt("10", 10)   // 10 — decimal
parseInt("10", 16)   // 16 — hexadecimal
parseInt("10", 2)    // 2  — binary
parseInt("0x1F")     // 31 — hex prefix auto-detected (but explicit is safer)

IEEE 754 internals, the Number abstract operations, and BigInt

The bit layout of a double

A JavaScript number is 64 bits: bit 63 = sign, bits 62–52 = biased exponent (bias 1023), bits 51–0 = fraction (mantissa). Value = (−1)^s × 2^(e−1023) × (1.fraction). Special values: exponent all 1s and fraction 0 = ±Infinity; exponent all 1s and fraction non-zero = NaN. The 2⁵³ safe-integer limit comes from the 52-bit mantissa (implicit leading 1 adds the 53rd bit).

-0 (negative zero)

IEEE 754 has +0 and −0. In JavaScript they compare equal but behave differently:

0 === -0          // true
1 / 0             // Infinity
1 / -0            // -Infinity — this distinguishes them
Object.is(0, -0)  // false — strict identity (not ===)

ToNumber abstract operation (ECMA-262 §7.1.4)

When JS converts a value to a number (e.g. in + "42" or Number(val)), it calls the internal ToNumber abstract operation. Key conversions: undefined → NaN, null → +0, true → 1, false → +0, string → parse (trim whitespace, then numeric literal rules, or NaN if invalid), object → call ToPrimitive with "number" hint, then ToNumber on the result.

BigInt internals

BigInt values are stored as sign + magnitude arrays of 64-bit limbs. Operations on BigInts are O(n) in the number of limbs (unlike Number which is O(1)). BigInt and Number are separate numeric types — the spec defines a separate ToNumeric operation (§7.1.3) that returns either Number or BigInt, used by arithmetic operators to dispatch to the right implementation. You cannot mix them without explicit conversion:

BigInt(42) + 10n       // 52n — ok
Number(10n) + 42       // 52  — ok (loses precision for large values)
10n + 42               // TypeError: Cannot mix BigInt and other types

Math — not a constructor

Math is a plain object (not a function) with a [[Prototype]] of Object.prototype. All its methods are defined in ECMA-262 §21.3. Implementation latitude is explicitly granted for transcendental functions (sin, cos, log, etc.) — the spec says they should compute "an implementation-dependent approximation", so results may vary by one ULP between engines.

Official Sources

The Codex links only to official documentation and the ECMAScript specification. No third-party tutorials.