JavaScript Number EPSILON Property

What You’ll Learn

Number.EPSILON is a static data property on Number (same API as MDN Number.EPSILON). It is the difference between 1 and the next greater representable Number — about 2.22e-16. This tutorial covers its value, float equality, when not to use a bare EPSILON, five examples, and try-it labs.

Introduction

JavaScript numbers use IEEE-754 double precision. Only finitely many values fit in 64 bits, so many decimals — including 0.1 — are approximations. That is why 0.1 + 0.2 === 0.3 is false.

Number.EPSILON names the spacing between 1 and the next Number. Near magnitude 1, that spacing is a common starting tolerance for “close enough” equality checks.

This page is part of JavaScript Number Properties. Related tools include Number.isNaN() and Number.isFinite() for validating numeric results.

Understanding the EPSILON Property

Double precision stores a 52-bit fraction (mantissa). At magnitude 1, the least significant bit is worth 2−52 — that is Number.EPSILON.

• It is a constant number, not a method.
• It describes accuracy around 1, not absolute accuracy everywhere.
• As numbers grow, the gap between representable values also grows.
• It is much larger than Number.MIN_VALUE (the tiniest positive Number).

📝 Syntax

General form of the static property Number.EPSILON:

Number.EPSILON

Value

2−52, approximately 2.220446049250313e-16.

Property attributes

Common patterns

Number.EPSILON;                         // ≈ 2.220446049250313e-16
Number.EPSILON === 2 ** -52;            // true

Math.abs(0.2 - 0.3 + 0.1) < Number.EPSILON;  // true

function equal(x, y, tolerance = Number.EPSILON) {
  return Math.abs(x - y) < tolerance;
}

Examples Gallery

Examples follow MDN Number.EPSILON patterns. Use View Output or Try It Yourself for each case.

Number.EPSILON;
Number.EPSILON === 2 ** -52;  // true

2.220446049250313e-16
true

const result = Math.abs(0.2 - 0.3 + 0.1);

result;                       // 2.7755575615628914e-17
result < Number.EPSILON;      // true

2.7755575615628914e-17
true

function equal(x, y) {
  return Math.abs(x - y) < Number.EPSILON;
}

equal(0.1 + 0.2, 0.3);  // true
0.1 + 0.2 === 0.3;      // false

true
false

function equal(x, y) {
  return Math.abs(x - y) < Number.EPSILON;
}

const x = 1000.1;
const y = 1000.2;
const z = 2000.3;

x + y;            // 2000.3000000000002
equal(x + y, z);  // false

2000.3000000000002
false

function equal(x, y, tolerance = Number.EPSILON) {
  return Math.abs(x - y) < tolerance;
}

const x = 1000.1;
const y = 1000.2;
const z = 2000.3;

equal(x + y, z, 2000 * Number.EPSILON);  // true

true

🚀 Common Use Cases

• Near-1 equality — compare results of float math when values are around 1.
• Geometry / graphics — treat residuals as zero when they fall under a chosen epsilon.
• Unit tests — assert approximate equality instead of brittle ===.
• Teaching floating point — explain why decimals misbehave in binary IEEE-754.
• Scaled checks — multiply EPSILON by magnitude for larger numbers.
• Not a universal default — form inputs with step 0.1 often need a much larger tolerance.

📝 Notes

• This is a static property — use Number.EPSILON only.
• Do not write Number.EPSILON() — it is not a function.
• Do not use bare EPSILON for every float comparison.
• Accuracy decreases as magnitude increases.
• Number.MIN_VALUE is a different concept (smallest positive Number).
• Prefer a tolerance that matches your data’s magnitude and precision.

💡 Best Practices