JavaScript: JavaScript Numbers and Math

Last updated: 2026-10-13

In JavaScript, there is only one number type: Number. Whether it's an integer or a decimal, it's all Number. This is different from languages like Java or C that distinguish between int, float, and so on. Simpler, yes — but it comes with a few gotchas.

Related Math Methods：Number.isNaN() Math.random() Math.floor() Math.round() Math.ceil() Math.abs() Math.max() Math.min() Math.pow() isFinite() toFixed() Number() parseInt Math

1. Number Type

In JavaScript, both integers and floating-point numbers are the Number type — there is no separate integer type.

<script>
let a = 42;        // This is a Number
let b = 3.14;      // This is also a Number
typeof a;          // "number"
typeof b;          // "number"
</script>

Numbers can also be written in several other formats:

<script>
let hex = 0xFF;       // Hexadecimal, equals 255
let octal = 0o10;     // Octal, equals 8
let binary = 0b1010;  // Binary, equals 10
let big = 1e6;        // Scientific notation, equals 1000000
</script>

2. NaN and Infinity

NaN stands for "Not a Number," yet it is of type Number — one of JavaScript's most ironic design choices.

<script>
typeof NaN;          // "number"  ← That's right, it's actually a number
NaN === NaN;         // false     ← It's not even equal to itself!
Number.isNaN(NaN);   // true      ← Use this method to check for NaN
</script>

When does NaN appear? When you try to do math with something that isn't a number:

<script>
parseInt('abc');    // NaN
'hello' * 5;       // NaN
Math.sqrt(-1);     // NaN
</script>

Infinity represents positive infinity and appears when dividing by zero:

<script>
1 / 0;             // Infinity
-1 / 0;            // -Infinity
typeof Infinity;   // "number"
</script>

3. Floating-Point Precision

This is JavaScript's most famous quirk: 0.1 + 0.2 !== 0.3.

<script>
0.1 + 0.2;          // 0.30000000000000004
0.1 + 0.2 === 0.3;  // false
</script>

The reason is related to how computers store floating-point numbers in binary. The value 0.1 is a repeating fraction in binary, leading to precision loss during storage. This isn't unique to JavaScript — all languages using the IEEE 754 standard have this issue.

The fix: use toFixed() for formatting, or scale up before computing:

<script>
(0.1 + 0.2).toFixed(2);   // "0.30"
(0.1 * 100 + 0.2 * 100) / 100;  // 0.3
</script>

▶ Example: Precision Issues Demo

4. The Math Object

Math is JavaScript's built-in math utility. No instantiation needed — just call its methods directly:

▶ Example: Common Math Methods

5. toFixed() — Formatting Decimals

toFixed(n) formats a number to n decimal places and returns a string:

<script>
let price = 9.9;
price.toFixed(2);    // "9.90"  ← Note: returns a string
+(9.9).toFixed(2);   // 9.9     ← Use + to convert back to a number
</script>

6. toString() — Base Conversion

The number method toString(radix) converts a number to a string in the specified base:

<script>
(255).toString(16);   // "ff"  hexadecimal
(255).toString(2);    // "11111111"  binary
(255).toString(8);    // "377"  octal
(100).toString();     // "100"  decimal (default)
</script>

▶ Example: Base Conversion

7. Math.random() — Generating Random Numbers

Math.random() returns a random floating-point number between 0 (inclusive) and 1 (exclusive). In practice, you often need a random integer within a specific range:

<script>
// Generate a random integer between min and max (inclusive)
function getRandomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}
</script>

▶ Example: Random Number Demo

Related Math Methods：Number.isNaN() Math.random() Math.floor() Math.round() Math.ceil() Math.abs() Math.max() Math.min() Math.pow() isFinite() toFixed() Number() parseInt Math

❓ FAQ

📖 Summary

• JavaScript has only one Number type — both integers and decimals are Number
• NaN is not equal to any value (including itself); use Number.isNaN() to detect it
• 0.1 + 0.2 !== 0.3 is a precision issue; fix it with toFixed() or by scaling up and down
• Math.floor rounds down, Math.ceil rounds up, Math.round rounds to the nearest integer
• Formula for a random integer: Math.floor(Math.random() * (max - min + 1)) + min
• toFixed() returns a string — convert it back to a number if you need to do further math

📝 Exercises

1. Write a program that takes a circle's radius as input, calculates its area and circumference, and displays the results rounded to 2 decimal places.
2. Write a number guessing game: the program randomly generates an integer between 1 and 100, the user enters guesses, and the program responds with "Too high" or "Too low" until the correct answer is found.
3. Write a base converter: input a decimal number and simultaneously display its binary, octal, and hexadecimal equivalents.

Web-Tutorial Tech Team

A team of developers maintaining programming tutorials. Each tutorial is written and reviewed by developers with expertise in that field. We work to keep our content accurate and reliable — if you spot an issue, please let us know.

About Us