Numbers in JavaScript
There are two different kinds of numbers in JavaScript - numbers and "bigints"
Numbers are the most used, and represent numeric data type in the double-precision 64-bit floating-point format.
let numericValue = 42;
// => 42
A number literal like 42 in JavaScript code is a floating-point value, not an integer. There is no separate integer type in common everyday use. The bigint type is not designed to replace the number type for everyday uses. 42 is still a Number, not a BigInt.
Numbers may also be expressed in literal forms like 0b101, 0o13, 0x0A. Learn more on numeric lexical grammar here.
Special Notations
Exponential Notation
The E-notation indicates a number that should be multiplied by 10 raised to a given power. The format of E-notation is to have a number, followed by e or E, than by the power of 10 to multiply by.
const num = 3.125e7;
// => 31250000
// The notation essentially says, "Take 3.125 and multiply it by 10^7".
E-notation can also be used to represent very small numbers:
const num = 325987e-6; // Equals to 0. 325987
// The notation essentially says, "Take 325987 and multiply it by 10^-6.
Underscore Notation
Underscores can be used to make large numbers easier to read for the user. The compiler will completely ignore the underscores.
const num = 1_000_000; // You can read this as 1,000,000
console.log(num);
// => 1000000
Built-in Object
There are two built-in objects that are useful when dealing with numbers:
Math also includes methods for rounding numbers. You can read more about the available rounding options in this javascript.info article on rounding.
Math.floor(234.34); // => 234
Math.ceil(234.34); // => 235
The Number built-in global object is also a global function that can be used to convert almost anything number-like to a number. It is less forgiving than parsing a string to a number.
const date = new Date('December 17, 1995 03:24:00');
const unix = Number(date);
unix;
// => 819199440000
There are three types of maximum (and minimum / maximum negative) values for numbers in JavaScript:
Because of how numbers in JavaScript are implemented, not every number between Number.MIN_VALUE and Number.MAX_VALUE can be represented. However, every number between Number.MIN_SAFE_INTEGER - 1 and Number.MAX_SAFE_INTEGER + 1 can be represented.
Special Numbers Values
JavaScript has several special number values:
NaN - Not a Number
The error value NaN(aka "Not a Number") is produced in the following cases.
NaN is the only value that is not equal to itself:
NaN === NaN; // => false
If you want to check whether a value is NaN, you have to use the global function isNaN():
isNaN(NaN); // => true
isNaN(123); // => false
Infinity
Infinity is an error value indicating one of two problems:
Infinity is larger than any other number (except NaN). Similarly, -Infinity is smaller than any other number (except NaN)
The global function isFinite() allows you to check whether a value is an actual number (neither infinite nor NaN):
isFinite(80085); // => true
isFinite(Infinity); // => false
isFinite(NaN); // => false
The Two Zeros
+0 or -0 are distinct numbers in JavaScript. They can be produced if you represented a number, that is so small that it is indistinguishable from 0. The signed zero allows you to record “from which direction” you approached zero; that is, what sign the number had before it was considered zero. It is best practise to pretend there's only one zero.
Comparison
Numbers are considered equal if they have the same value.
1 == 1.0;
// => true
1 === 1.0;
// => true
// Remember, all numbers are floating-points, so this is
// different syntax for the exact same value.
1 === 1n;
// => false
// Strictly checking a number against a bigint will always result
// in false.
See comparison for more information on comparisons in general and comparing numeric values in JavaScript.
Pitfalls
Because numbers in JavaScript are floating-point numbers, all math using these values is floating-point math. Therefore, in JavaScript:
0.1 + 0.2 === 0.3;
// => false
See 0.30000000000000004.com for a brief explanation and Appendix D of Oracle's Numerical Computation Guide "What Every Computer Scientist Should Know About Floating-Point Arithmetic" for an in-depth explanation.
Note: copied from Excercism