In JavaScript, numbers are used to represent numerical values. They can be whole numbers (like 5, 10, 100) or decimal numbers (like 3.13, 0.5, 10.75). For example,
let num1 = 5;
let num2 = 3.13;
console.log(num1); // 5
console.log(num2); // 3.13
JavaScript NaN
NaN (Not a Number) is a special value that is returned when a mathematical operation cannot produce a meaningful numeric result.
Performing arithmetic operations (except addition) on numeric values and strings results in NaN. For example,
let num = 4 - "hello";
console.log(num); // NaN
When the typeof operator is used for NaN value, it gives number as an output. For example,
let num = 4 - "hello";
console.log(num); // NaN
console.log(typeof num); // number
The built-in isNaN() function can be used to find if a value is a number. For example,
let num1 = isNaN(9);
console.log(num1); // false
let num2 = isNaN(4 - "hello");
console.log(num2); // true
JavaScript Infinity
Infinity is a special value that signifies an amount larger than any finite number. For example,
let num1 = 2 / 0;
console.log(num1); // Infinity
let num2 = -2 / 0;
console.log(num2); // -Infinity
Here, dividing a positive number by 0 yields Infinity, while dividing a negative number by 0 results in -Infinity.
You can use the exponential notation e to represent numbers that are very large or very small. For example,
let num1 = 5e9;
console.log(num1); // 5000000000
let num2 = 5e-5;
console.log(num2); // 0.00005
Numbers can also be denoted in hexadecimal notation. For example,
let num1 = 0xff;
console.log(num1); // 255
let num2 = 0x00;
console.log(num2); // 0
JavaScript Number Methods
Here is a 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() | Converts the numeric floating string to a floating-point number. |
| parseInt() | Converts the numeric string to an integer. |
| toExponential() | Returns a string value for a number in exponential notation. |
| toFixed() | Returns a string value for a number in fixed-point notation. |
| toPrecision() | Returns a string value for a number to a specified precision. |
| toString() | Returns a string value in a specified radix (base). |
| valueOf() | Returns the number's value. |
| toLocaleString() | Returns a string with a language-sensitive representation of a number. |
Example: JavaScript Number Methods
// check if num1 is integer
let num1 = 12;
console.log(Number.isInteger(num1)); // true
// check if num2 is NaN
let num2 = NaN;
console.log(Number.isNaN(num2)); // true
// display up to two decimal points
let num3 = 5.1234;
console.log(num3.toFixed(2)); // 5.12
More on JavaScript Numbers
When + is only used with numbers, it adds those numbers. For example,
let num = 4 + 9;
console.log(num); // 13
console.log(typeof num); // number
When + is used with numbers and strings, it concatenates them by converting the number to a string. For example,
let string_num = "4" + 9;
console.log(string_num); // 49
console.log(typeof string_num); // string
When a numeric string is used with other numeric operators, the numeric string is converted to a number. For example,
let num = "5" - 2;
console.log(num); // 3
num = "5" / 2;
console.log(num); // 2.5
num = "5" * 2;
console.log(num); // 10
In JavaScript, numbers (especially decimals) aren't always stored accurately, leading to precision problems. For example,
let num = 0.1 + 0.2;
console.log(num); // 0.30000000000000004
The result should be 0.3 instead of 0.3000000000004.
This error occurs because JavaScript stores numbers in binary form to represent decimal digits. And decimal numbers can't be represented in binary form exactly.
We can mitigate the precision problem in the following ways:
1. Converting Floating-Point Numbers to Integers
let num = (0.1 * 10 + 0.2 * 10) / 10;
console.log(num); // 0.3
2. Using the toFixed() Method
let num = 0.1 + 0.2;
console.log(num.toFixed(2)); // 0.30
Here, toFixed(2) rounds up the decimal number to two decimal values.
The number type can only represent values less than (2^53 - 1) and more than -(2^53 - 1).
However, if you need to use a larger or smaller number than that, you can use the BigInt data type. BigInt allows you to do calculations with any size or precision.
A BigInt number is created by appending n to the end of an integer. For example,
// BigInt value
let value = 900719925124740998n;
// add two big integers
let value1 = value + 1n;
console.log(value1);
// Output: 900719925124740999n
Note: BigInt was introduced in a newer version of JavaScript and is not supported by many browsers. To learn more, visit JavaScript BigInt support.
The Number() function converts data of various types to numbers. For example,
let variable1 = "23"; // string
let variable2 = true; // boolean
//convert to number
let result1 = Number(variable1);
let result2 = Number(variable2);
console.log(result1); // 23
console.log(result2); // 1
To learn more about number conversion, visit JavaScript Type Conversion.
In JavaScript, numbers can be represented either as primitive values or as instances of the Number object.
Number objects can be created using the new keyword. For example,
// create a number object
let num = new Number(45);
console.log(num);
console.log(typeof num);
Output
[Number: 45] object
Note: Avoid using Number objects since they slow down the program.
Also Read: