How Can We Help?

# Numbers

## Introduction to the JavaScript Number

JavaScript uses the `number` type to represent both integers and floating-point values. Technically, the JavaScript `number` type uses the IEEE-754 format.

ES2020 introduced a new primitive type `bigint` representing big integer numbers with values larger than 253 – 1.

To support various types of numbers, JavaScript uses different number literal formats.

## Integer numbers

The following shows how to declare a variable that holds a decimal integer:

``````let counter = 100;
``````

Integers can be represented in the following formats:

• Octal (base 8)

When you use the octal and hexadecimal numbers in arithmetic operations, JavaScript treats them as decimal numbers.

### Octal numbers

An octal literal number starts with the digit zero (0) followed by a sequence of octal digits (numbers from 0 through 7). For example:

``````let num = 071;
console.log(num);
``````

Output:

``````57
``````

If an octal number contains a number not in the range from 0 to 7, the JavaScript engine ignores the 0 and treats the number as a decimal. For example:

``````let num = 080;
console.log(num);
``````

Output:

``````80
``````

This implicit behavior might cause issues. Therefore, ES6 introduced a new octal literal that starts with `0o` followed by a sequence of octal digits (from 0 to 7). For example:

``````let num = 0o71;
console.log(num);
``````

Output:

``````57
``````

If you have an invalid number after `0o`, JavaScript will issue a syntax error like this:

``````let num = 0o80;
console.log(num);
``````

Output:

``````let num = 0o80;
^^
SyntaxError: Invalid or unexpected token
``````

Hexadecimal numbers start with 0x or 0X followed by any number of hexadecimal digits (0 through 9, and a through f). For example:

``````let num = 0x1a;
console.log(num);
``````

Output:

``````26
``````

## Floating-point numbers

To define a floating-point literal number, you include a decimal point and at least one number after that. For example:

``````let price = 9.99;
let tax = 0.08;
let discount = .05; // valid but not recommended
``````

When you have a very big number, you can use e-notation. E-notation indicates a number should be multiplied by 10 raised to a given power. For example:

``````let amount = 3.14e7;
console.log(amount);
``````

Output:

``````31400000
``````

The notation `3.14e7` means that take `3.14` and multiply it by `107`.

Likewise, you can use the E-notation to represent a very small number. For example:

``````let amount = 5e-7;
console.log(amount);
``````

Output:

``````0.0000005Code language: CSS (css)
``````

The 5e-7 notation means that take 5 and divide it by 10,000,000.

Also, JavaScript automatically converts any floating-point number with at least six zeros after the decimal point into e-notation. For example:

``````let amount = 0.0000005;
console.log(amount);
``````

Output:

``````5e-7
``````

Floating-point numbers are accurate up to 17 decimal places. When you perform arithmetic operations on floating-point numbers, you often get the approximate result. For example:

``````let amount = 0.2 + 0.1;
console.log(amount);
``````

Output:

``````0.30000000000000004
``````

## Big Integers

JavaScript introduced the `bigint` type starting in ES2022. The `bigint` type stores whole numbers whose values are greater than 253 – 1.

A big integer literal has the `n` character at the end of an integer literal like this:

``````let pageView = 9007199254740991n;
``````

## Summary

• JavaScript Number type represents both integer and floating-point numbers.