JavaScript Number

JavaScript Number

In this tutorial, you will learn about JavaScript Number with the help of examples.

In JavaScript, numbers are the primitive data types. For example,

let a = 3;
let b = 3.13;

Unlike in some other programming languages, you don't have to specifically declare for integer or floating values using int, float, etc.

You can use exponential notation e to include too large or too small numbers. For example,

let a1 = 5e9;
console.log(a1); //5000000000

let a2 = 5e-5;
console.log(a2); // 0.00005

Numbers can also be denoted in hexadecimal notation. For example,

let a = 0xff;
console.log(a); // 255

let b = 0x00 ;
console.log(b); // 0

+ Operator with Numbers

When + is used with numbers, it is used to add the numbers. For example,

let a = 4 + 9;
console.log(a); // 13

When + is used with numbers and strings, it is used to concatenate them. For example,

let a = '4' + 9;
console.log(a); // 49

When a numeric string is used with other numeric operations, the numeric string is converted to a number. For example,

let a = '4' - 2;
console.log(a); // 2

let a = '4' / 2;
console.log(a); // 2

let a = '4' * 2;
console.log(a); // 8

JavaScript NaN

In JavaScript, NaN(Not a Number) is a keyword that indicates that the value is not a number.

Performing arithmetic operations( except + ) to numeric value with string results in NaN. For example,

let a = 4 - 'hello';
console.log(a); // NaN

The built-in function isNaN() can be used to find if a value is a number. For example,

let a = isNaN(9);
console.log(a); // false

let a = isNaN(4 - 'hello');
console.log(a); // true

When the typeof Operator is used for NaN value, it gives a number output. For example,

let a = 4 - 'hello';
console.log(a); // NaN
console.log(typeof a); // "number"

JavaScript Infinity

In JavaScript, when the calculation is done that exceeds the largest possible number, Infinity( or -Infinity) is returned. For example,

let a = 2 / 0;
console.log(a); // Infinity

let a = -2 / 0;
console.log(a); // -Infinity

JavaScript BigInt

In JavaScript, Number type can only represent numbers less than (253 - 1) and more than -(253 - 1). However, if you need to use a larger number than that, you can use the BigInt data type.

A BigInt number is created by appending n to the end of an integer. For example,

// BigInt value
let value = 900719925124740998n;

// Adding two big integers
let value1 = value + 1n;
console.log(value1); // returns "900719925124740999n"

Note: BigInt was introduced in the newer version of JavaScript and is not supported by many browsers. Visit JavaScript BigInt support to learn more.

JavaScript Numbers Are Stored in 64-bit

In JavaScript, numbers are stored in 64-bit format IEEE-754, also known as "double precision floating point numbers".

The numbers are stored in 64 bits(the number is stored in 0 to 51 bits, the exponent in 52 to 62 bits and the sign in 63 bits)

Numbers Exponent Sign
52 bits(0 - 51) 11 bits(52- 62) 1 bit(63)

Precision Problems

Operations on floating-point numbers results in some unexpected results. For example,

let a = 0.1 + 0.2;
console.log(a); // 0.30000000000000004

The result should be 0.3 instead of 0.30000000000000004. This error occurs because in JavaScript, numbers are stored in binary form to represent decimal digits internally. And decimal numbers can't be represented in binary form exactly.

To solve the above problem, you can do something like this:

let a = (0.1 * 10 + 0.2 * 10) / 10;
console.log(a); // 0.3

You can also use the toFixed() method.

let a = 0.1 + 0.2;
console.log(a.toFixed(2)); // 0.30

toFixed(2) rounds up the decimal number to two decimal values.

let a = 9999999999999999
console.log(a); // 10000000000000000

Note: Integers are accurate up to 15 digits.

Number Objects

You can also create numbers using the new keyword. For example,

let a = 45;

// creating a number object
let b = new Number(45);

console.log(a); // 45
console.log(b); // 45

console.log(typeof a); // "number"
console.log(typeof b); // "object"

Note: It is recommended to avoid using number objects. Using number objects slows down the program.

JavaScript Number Methods

Here is the list of built-in number methods in JavaScript.

Method Description
isNaN() determines whether the passed value is NaN
isFinite() determines whether the passed value is a finite number
isInteger() determines whether the passed value is an integer
isSafeInteger() determines whether the passed value is a safe integer
parseFloat(string) converts the numeric floating string to floating-point number
parseInt(string, [radix]) converts the numeric string to integer
toExponential(fractionDigits) returns a string value for a number in exponential notation
toFixed(digits) returns a string value for a number in fixed-point notation
toPrecision() returns a string value for a number to a specified precision
toString([radix]) returns a string value in a specified radix(base)
valueof() returns the numbers value
toLocaleString() returns a string with a language sensitive representation of a number

For example,

// check if a is integer
let a = 12;
console.log(Number.isInteger(a)); // true

// check if b is NaN
let b = NaN;
console.log(Number.isNaN(b)); // true

// display upto two decimal point
let d = 5.1234;
console.log(d.toFixed(2)); // 5.12

JavaScript Number Properties

Here is the list of Number properties in JavaScript.

Property Description
EPSILON returns the smallest interval between two representable numbers
MAX_SAFE_INTEGER returns the maximum safe integer
MAX_VALUE returns the largest possible value
MIN_SAFE_INTEGER returns the minimum safe integer
MIN_VALUE returns the smallest possible value
NaN represents 'Not-a-Number' value
NEGATIVE_INFINITY represents negative infinity
POSITIVE_INFINITY represents positive infinity
prototype allows the addition of properties to Number objects

For example,

// largest possible value
let a = Number.MAX_VALUE;
console.log(a); // 1.7976931348623157e+308

// maximum safe integer
let a = Number.MAX_SAFE_INTEGER;
console.log(a); // 9007199254740991

JavaScript Number() Function

The Number() function is used to convert various data types to numbers. For example,

let a = '23'; // string
let b = true; // boolean

//converting to number
let result1 = Number(a);
let result2 = Number(b);

console.log(result1); // 23
console.log(result2); // 1

If you want to learn more about the number conversion, visit JavaScript Type Conversion.