Number & Math in depth

Which numbers JavaScript can store exactly

The Numbers & math lesson showed the basics: the 0.1 + 0.2 surprise, NaN, Infinity, rounding, reading numbers from text, and the Math object. This lesson stays with the same type, number, and looks closer.

JavaScript stores every number in the same fixed amount of memory: 64 bits. That is enough for very big and very small numbers. It is not enough to store every number exactly. So JavaScript stores the nearest number it can.

Think of all the numbers JavaScript can store as marks on a long ruler:

• Near 1, the marks are very close together.
• Far from zero, the marks are far apart.
• A number between two marks is moved to the nearest mark.

Most number bugs come from asking the wrong question. This lesson helps you ask the right one:

• Is this a real, finite number?
• Is this whole number stored exactly?
• How should I show this number as text?
• Is this random choice fair?

You will also meet two new tools, Math.sumPrecise and Math.f16round. Older browsers don't have them yet. So this page first checks whether your browser has them, and only then uses them.

Number.EPSILON is the gap between 1 and the next number JavaScript can store. It is about 0.0000000000000002. On the ruler, it is the space between the mark at 1 and the next mark.

It helps with decimals. 0.1 + 0.2 is not exactly 0.3, but the difference is smaller than Number.EPSILON. So you can say the two are "close enough". For bigger numbers the marks are farther apart, so you must make the allowed difference bigger too.

Whole numbers have a limit too. A whole number is safe when JavaScript can store it and every whole number below it exactly. The biggest safe whole number is Number.MAX_SAFE_INTEGER, which is 2 ** 53 - 1, or 9007199254740991. (** means "to the power of".)

Step through the code below. Watch what happens just past the last safe whole number. A number can be whole and still not be safe.

1const maxSafe = Number.MAX_SAFE_INTEGER;Run2console.log(maxSafe + 1);3console.log(maxSafe + 2);4console.log(Number.isSafeInteger(maxSafe + 1));5console.log(Math.abs(0.1 + 0.2 - 0.3) < Number.EPSILON);

The next code has four small checks.

const total = 0.1 + 0.2;
console.log(total === 0.3);
console.log(Math.abs(total - 0.3) < Number.EPSILON);
console.log(Math.abs(1000000000000.1 - 1000000000000) < Number.EPSILON);
console.log(Object.is(-0, 0));

Line by line:

• Line 1 adds 0.1 + 0.2 and keeps the result in total.
• Line 2 asks whether total is exactly 0.3. It prints false, because the decimals are stored a tiny bit off.
• Line 3 asks whether the difference is smaller than Number.EPSILON. It prints true.
• Line 4 does the same for two numbers near one trillion. Their difference is about 0.1, which is far bigger than Number.EPSILON. It prints false.
• Line 5 compares -0 and 0 with Object.is. It prints false.

Line 4 shows that Number.EPSILON alone is too small for big numbers. For big numbers, pick an allowed difference that fits your data, like one cent for prices.

JavaScript has a minus zero, -0. -0 === 0 is true, so === can't tell them apart. Object.is(a, b) checks whether two values are exactly the same, so it can.

The biggest number, the smallest number, and Infinity

Safe whole numbers answer one question: "Which whole numbers are stored exactly?" Two other limits answer a different question: "How big, or how close to zero, can a normal number get?"

• Number.MAX_VALUE is the biggest number JavaScript can store. It is about 1.8e308.
• Number.MIN_VALUE is the smallest number above zero that JavaScript can store. It is about 5e-324.

The e means "times 10 to the power of". So 1.8e308 is a whole number with 309 digits, and 5e-324 is a tiny number with 323 zeros after the decimal point before the 5.

The four names below sound alike but mean different things. Each row gives the name, what it really means, and when you need it.

When a result is too big, JavaScript doesn't throw an error. It gives Infinity instead. Some code uses Infinity on purpose, for example as a starting value when you look for the smallest number. But for things people see, like prices, distances, or percentages, treat Infinity as wrong data.

JavaScript has two sets of checks for NaN ("not a number") and for finite numbers. A finite number is a normal number: not NaN, not Infinity, and not -Infinity.

• The old global checks, isNaN and isFinite, first change the value into a number. Then they check it.
• The newer checks, Number.isNaN and Number.isFinite, change nothing. A value that is not a number is never NaN and never finite to them.

That one difference explains every result below.

The table runs all four checks on six values. Read one row at a time: the first cell is the value, and the other cells show what each check returns.

Look at the "" row. The empty string turns into 0, so the global isFinite says true. That is how an empty form field can slip through as zero.

Use the global checks only when you want that change into a number to happen. When you check user input, change it yourself with Number(input), then use the Number. checks.

There are two checks for whole numbers too:

• Number.isInteger(x) asks: "Is this a number with nothing after the decimal point?"
• Number.isSafeInteger(x) asks: "Is this a whole number, and is it stored exactly?"

These methods answer one question: "How should this number look as text?" Each one returns a string.

• toPrecision(5) keeps 5 significant digits. Those are the digits that count, starting from the first digit that is not zero. (123.456).toPrecision(5) gives "123.46".
• toExponential(2) writes the number with an e, keeping 2 digits after the decimal point. (123.456).toExponential(2) gives "1.23e+2", which means 1.23 times 10 to the power of 2.
• toString(radix) writes the number in another base. The base, also called the radix, is how many different digits you use. We normally use base 10: the digits 0 to 9. Base 2 (binary) uses only 0 and 1. Base 16 (hexadecimal, or "hex") uses 0 to 9 and then a to f. Any base from 2 to 36 works.

console.log(parseInt("1010", 2));
console.log((255).toString(2));
console.log((1234.5).toFixed(2));
console.log((1234.5).toPrecision(4));

Line by line:

• Line 1 reads the text "1010" as base 2. The second argument, 2, is the base. It prints 10.
• Line 2 goes the other way. It writes 255 in base 2 and prints 11111111.
• Line 3 keeps exactly 2 digits after the decimal point. It prints 1234.50.
• Line 4 keeps 4 significant digits. It rounds 1234.5 to 1235.

All of these give back a string. Use them to show a number to people. Don't do more math on the result.

Now try the number inspector. Type a number or click a preset, especially 2 ** 53, 5e-324, and -0. The "number just below" and "number just above" rows show the closest numbers JavaScript can store on each side. The gap between them is the space between the marks on the ruler at that spot.

1const value = Number(input);2Number.isInteger(value);3Number.isSafeInteger(value);4value.toPrecision(5);5value.toExponential(2);6value.toFixed(2);7value.toString(2);8value.toString(16);

Math is a ready-made toolbox of number functions. You don't create it with new; you just call its functions, like Math.max. This section uses four groups of tools:

• Rounding: Math.round, Math.floor, Math.ceil, and Math.trunc.
• Angles: Math.sin, Math.cos, and Math.atan2. This part of math is called trigonometry.
• Logarithms: Math.log10(x) asks "10 to what power gives x?", and Math.log2(x) asks the same for 2. Math.log uses the number e (about 2.718).
• Distance: Math.hypot(a, b) gives the length of the long side of a right triangle with sides a and b.

The angle functions don't use degrees. They use radians, another way to measure angles. 180 degrees is π radians. The code below changes degrees into radians, then calls real Math functions. At 180 degrees, Math.sin(Math.PI) gives 1.2246467991473532e-16. That is not zero, but it is very close. It happens because Math.PI is stored a tiny bit off.

1const degrees = 180;Run2const radians = degrees * Math.PI / 180;3console.log(Math.sin(radians));4console.log(Math.hypot(3, 4));5console.log(Math.log10(1000));6console.log(Math.log2(8));

console.log(Math.round(2.5));
console.log(Math.round(-2.5));

Line 1 prints 3. Line 2 prints -2, not -3. Going up from -2.5 means going toward the bigger number, and -2 is bigger than -3. So Math.round does not always round away from zero.

Math.random() gives a random-looking number from 0 up to 1. It can be 0, but it is never 1. It is fine for games, changing how a page looks, simulations, and demos.

It is not safe for secrets. Someone could guess the numbers it makes. For tokens, passwords, or IDs that must be hard to guess, use the browser's Web Crypto tools, such as crypto.getRandomValues() or crypto.randomUUID(). The Web Crypto lesson covers them.

Two common bugs make random results unfair:

• Math.round(Math.random() * 6) for a die roll. It can give 0, and it gives 0 and 6 only half as often as the other results.
• array.sort(() => Math.random() - 0.5) to shuffle. sort expects its compare function to give the same answer for the same two items every time. A random answer breaks that, so some orders come up more often than others.

The fair way to shuffle is the Fisher–Yates shuffle. It walks from the last item to the first. For each spot, it swaps in a random item from the ones not placed yet. Every order is equally likely.

Click the button below to make real random samples in your browser. Compare the unfair and fair versions.

1function randomInt(min, max) {2  return Math.floor(Math.random() * (max - min + 1)) + min;3}4 5function shuffle(items) {6  const copy = [...items];7  for (let i = copy.length - 1; i > 0; i -= 1) {8    const j = Math.floor(Math.random() * (i + 1));9    [copy[i], copy[j]] = [copy[j], copy[i]];10  }11  return copy;12}

Some Math tools exist for special jobs: very exact sums, or working with other systems that store numbers in fewer bits. A bit is one binary digit, 0 or 1. A normal JavaScript number uses 64 bits. These tools work with 32 bits:

• Math.fround(x) rounds x to the nearest number that fits in 32 bits. Math.fround(5.5) stays 5.5, but Math.fround(5.05) becomes 5.050000190734863.
• Math.clz32(x) counts the zeros at the start of x, written as 32 binary digits. Math.clz32(1) gives 31: thirty-one zeros, then a single 1.
• Math.imul(a, b) multiplies two whole numbers the way a 32-bit system does. In that system, 0xffffffff means -1, so Math.imul(0xffffffff, 5) gives -5.

Math.sumPrecise and Math.f16round are newer, and some browsers don't have them yet. So this page waits until it is running in your browser, then checks whether they exist. It only calls them if they do.

• Math.sumPrecise adds a list of numbers exactly. Adding [1e16, 1, -1e16] one by one gives 0: the 1 is lost. Math.sumPrecise gives 1.
• Math.f16round rounds a number to fit in 16 bits. If your browser doesn't have it, the page only describes it.

The bitwise operators, like | and &, work on single bits. Before they start, they turn each side into a 32-bit whole number. That can change big numbers.

console.log((2 ** 32 + 1) | 0);

This prints 1. 32 bits can hold only 2 ** 32 different whole numbers. Past that, the count starts again from zero. So 2 ** 32 + 1 becomes just 1. This is useful for flags and quick hash codes, but don't use it to work with big whole numbers.

1console.log(Math.fround(5.5));Run2console.log(Math.fround(5.05));3console.log(Math.clz32(1));4console.log(Math.imul(0xffffffff, 5));5console.log(typeof Math.sumPrecise === "function");

1console.log(Math.fround(5.5));2console.log(Math.fround(5.05));3console.log(Math.clz32(1));4console.log(Math.imul(0xffffffff, 5));5console.log(typeof Math.sumPrecise === "function");

Where you’ll use this

These tools show up in everyday web work:

• Check form input: change it with Number(input), then use Number.isFinite. That way an empty field ("") doesn't slip through as zero.
• Check Number.isSafeInteger(id) before you trust a number ID to be exact. Keep bigger IDs as strings or as BigInt.
• Use toString(16) and toString(2) to look at colors, on/off flags, and bytes.
• Use Math.hypot(dx, dy) to find how far the mouse moved, for drawing on a canvas, or to decide when a drag starts.
• Use the Fisher–Yates shuffle for quizzes, flashcards, and playlists. Don't shuffle with a random sort.

Common misconceptions

Every code answer comes from real JavaScript output. Read the explanations for the wrong answers too.

Key takeaways

• Number.EPSILON is the gap next to 1. When you compare bigger numbers, make the allowed difference bigger too.
• Number.MAX_SAFE_INTEGER is about whole numbers being exact. Number.MAX_VALUE and Number.MIN_VALUE are about how big, or how close to zero, a number can get.
• Use the Number. checks. Use the global checks only when you want the value changed into a number first.
• toPrecision, toExponential, and toString(radix) write the same number as text in different ways.
• Math.random() is not safe for secrets. Round its result the wrong way and some results come up more often.
• Check that new tools like Math.sumPrecise and Math.f16round exist before you call them.

Up next: Internationalization with Intl. It shows numbers the way people in each country expect: money, languages, and units.