JavaScript Floating-Point Numbers

last modified April 1, 2025

JavaScript uses a single floating-point type based on the IEEE 754 standard, implemented as 64-bit numbers. This guide explores its properties, precision challenges, and best practices for handling numerical operations effectively.

JavaScript Number Overview

This section outlines JavaScript's sole numeric type: the 64-bit Number. It's based on IEEE 754 double-precision, offering a wide range and specific precision. Understanding its limits is key to avoiding common pitfalls in calculations. The example below shows its range and typical usage scenarios. Mastery of this type is essential for effective JavaScript programming.

// Number declarations
const singleNumber = 1.2345678901234567;
const smallNumber = 5.0e-324;
const largeNumber = 1.7976931348623157e308;

console.log(`Number: ${singleNumber}`);
console.log(`Smallest positive: ${smallNumber}`);
console.log(`Largest: ${largeNumber}`);

console.log(`\nNumber.MIN_VALUE: ${Number.MIN_VALUE}`);
console.log(`Number.MAX_VALUE: ${Number.MAX_VALUE}`);
console.log(`Size in bytes: ${8}`); // Always 64-bit

// Additional example: Scientific notation
const sciNotation = 1.23e-10;
console.log(`\nScientific notation: ${sciNotation}`);

JavaScript's Number type is a 64-bit floating-point value per the IEEE 754 double-precision standard, handling all numeric needs without separate float or decimal types. It offers 15-17 significant decimal digits and a range from ±5.0×10⁻³²⁴ (Number.MIN_VALUE) to ±1.7976931348623157×10³⁰⁸ (Number.MAX_VALUE), stored in 8 bytes.

This uniformity simplifies coding but demands caution, as precision issues arise with decimal fractions like 0.1. Unlike languages with multiple numeric types, JavaScript's single approach is versatile yet prone to rounding errors in specific cases. Use scientific notation (e.g., 1.23e-10) for very small or large values efficiently.

Precision and Rounding

Precision in JavaScript's Number type can be tricky due to its binary nature. This section explores how decimal fractions lead to rounding errors and how to mitigate them. Examples demonstrate built-in rounding methods and their quirks. Proper handling ensures accurate results in numeric operations. It's a critical skill for JavaScript developers to learn.

// Precision demonstration
const a = 0.1;
const b = 0.2;
const sum = a + b;

console.log(`0.1 + 0.2 = ${sum}`);
console.log(`0.1 + 0.2 === 0.3? ${sum === 0.3}`);
console.log(`Full precision: ${sum.toString()}`);

const value = 2.34567;
console.log(`\nRounding examples:`);
console.log(`Math.round(${value}): ${Math.round(value)}`);
console.log(`Math.floor(${value}): ${Math.floor(value)}`);
console.log(`Math.ceil(${value}): ${Math.ceil(value)}`);
console.log(`toFixed(2): ${value.toFixed(2)}`);

// Additional example: Pi rounding
const pi = 3.14159;
console.log(`\nPi to 3 digits: ${pi.toFixed(3)}`);

JavaScript's binary floating-point system struggles with decimal fractions like 0.1 + 0.2, yielding 0.30000000000000004 instead of 0.3 due to base-2 limitations. These small errors can grow in repeated calculations, making precision management vital for reliability.

Methods like Math.round (to nearest integer), Math.floor (down), and Math.ceil (up) adjust numbers, while toFixed(2) formats to two decimals but returns a string. For example, 2.34567 becomes 2.35 with toFixed(2), though the underlying value retains its full precision. Use these tools wisely, noting toFixed()'s string output requires parsing for further math.

Comparing Floating-Point Values

Comparing floating-point numbers in JavaScript needs special techniques due to precision issues. Direct equality checks often fail, so this section offers a robust alternative method. It also covers handling special values like NaN and Infinity. The example code clarifies these challenges with practical solutions. This knowledge prevents subtle bugs in comparison logic.

function nearlyEqual(a, b, epsilon = 1e-10) {

    const absA = Math.abs(a);
    const absB = Math.abs(b);
    const diff = Math.abs(a - b);

    if (a === b) return true;

    if (a === 0 || b === 0 || diff < Number.EPSILON) {
        return diff < (epsilon * Number.EPSILON);
    }
    
    return diff / (absA + absB) < epsilon;
}

const x = 0.1 + 0.2;
const y = 0.3;

console.log(`Direct equality: ${x === y}`);
console.log(`NearlyEqual: ${nearlyEqual(x, y)}`);
console.log(`Difference: ${x - y}`);

const nan = NaN;
const inf = Infinity;

console.log(`\nNaN === NaN: ${nan === nan}`);
console.log(`Number.isNaN(nan): ${Number.isNaN(nan)}`);
console.log(`inf === inf: ${inf === inf}`);

// Additional example: Small number comparison
const small = 1e-15;
console.log(`\nNearlyEqual(${small}, 0): ${nearlyEqual(small, 0)}`);

Using === for floating-point comparisons in JavaScript is risky, as 0.1 + 0.2 !== 0.3 due to tiny precision errors from binary representation. The nearlyEqual function uses an epsilon (e.g., 1e-10) to test if numbers are close enough, adjusting for relative size or absolute difference near zero with Number.EPSILON.

Special cases like NaN require Number.isNaNsince NaN !== NaN, while Infinity === Infinity holds true but needs context-aware handling. For tiny values like 1e-15 versus 0, nearlyEqual provides reliable results where direct checks fail. This approach ensures comparisons are both accurate and practical in real-world code.

Floating-Point for Financial Calculations

JavaScript's Number type isn't ideal for financial tasks needing exact decimals. This section shows its limitations and a workaround using integers for precision. Examples include interest calculations and rounding monetary values accurately. These techniques are crucial for reliable financial apps in JavaScript. Consider libraries for complex needs beyond these basics.

const principal = 1000.00;
const interestRate = 0.05; // 5%
const years = 10;

// Using floating-point
let futureValueFloat = principal * Math.pow(1 + interestRate, years);
console.log(`Future value (floating-point): $${futureValueFloat.toFixed(2)}`);

// Workaround with integer cents
const principalCents = 100000; // $1000.00 in cents
const futureValueCents = Math.round(principalCents * Math.pow(1 + interestRate, years));
const futureValue = futureValueCents / 100;
console.log(`Accurate future value: $${futureValue.toFixed(2)}`);

const payment = 123.456789;
console.log(`\nPayment to cents: ${payment.toFixed(2)}`);
console.log(`Payment rounded up: ${Math.ceil(payment * 100) / 100}`);
console.log(`Payment rounded down: ${Math.floor(payment * 100) / 100}`);

// Additional example: Tax calculation
const price = 19.99;
const taxRate = 0.08;
const tax = Math.round(price * taxRate * 100) / 100;
console.log(`\nTax on $${price}: $${tax}`);

JavaScript's floating-point Number type falters in financial calculations, as errors in calculations like compound interest (e.g., $1000 at 5% over 10 years) can skew results slightly. Using integers (e.g., cents) avoids this, converting $1000 to 100000 cents, computing, then dividing by 100 for an accurate $1628.89.

Rounding with toFixed(2) or Math.ceil()/Math.floor() on cents (e.g., 12345 cents to $123.45) ensures monetary precision, critical for accounting. For example, an 8% tax on $19.99 becomes exactly $1.60 with this method, avoiding floating-point drift. While effective, serious financial apps might still prefer libraries like Big.js for robustness.

Best Practices

Stick to Number for general math but switch to integer-based methods or libraries for financial precision in JavaScript. Avoid === for floating-point checks, opting for epsilon comparisons like nearlyEqual instead. Use Math.round, toFixed, or similar explicitly, noting toFixed returns strings needing parsing. Always test for NaN with Number.isNaN and Infinity with Number.isFinite to handle edge cases safely. These habits ensure your numeric code is both reliable and maintainable.

Source References

Learn more from these resources: MDN Number Documentation, MDN Math Documentation, and ECMAScript Number Type.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all JavaScript tutorials.