Numbers and Math

• Floating points: In JavaScript, numbers are all floating points, meaning they can have decimal points and the number of decimals is not fixed. It floats depending on the value.
• So the expression 10/8 resolves to 1.25.
• The expression 10/3 resolves to 3.333 etc. It cuts it off at some point.
• 10/2 resolves to 5. 

• Symbolic number values: The number data type includes a few symbolic values. 
• NaN: NaN stands for "not a number". It is used to represent a non-number value that has the number datatype: typeof NaN; // returns 'number'
• Infinity and -Infinity: typeof Infinity; // returns 'number'

• The Number.MAX_SAFE_INTEGER property returns the largest number that JavaScript can handle safely outside of BigInt. Number.MIN_SAFE_INTEGER returns the smallest safe number:

num = Number.MAX_SAFE_INTEGER; // returns 9007199254740991
num = Number.MIN_SAFE_INTEGER; // returns -9007199254740991

Number standard built-in object

• Like other primitive data types, number has a corresponding standard built-in object in the global scope called Number. While not technically a class, you can think of it as a JavaScript class. Number can instantiate objects, and has static and instance properties and methods that you can access to work with numeric data.

Object.getPrototypeOf(7) === Number.prototype; // true

• When called with the new operator, Number is a constructor function. It will create a number as an object, although style guides recommend using primitive numbers unless you have some specific reason to use a number object.

let num = new Number(7);
typeof num; // returns object.

2. Number function: convert other data types to number

• You can convert other data types to number primitive values by calling the Number function in a non constructor context, meaning without the keyword new. 

• Digit strings (i.e., numbers in quotes) convert to numbers.

let view = Number('7'); // returns 7

• Empty strings, strings with just white space, null values, and empty arrays convert to 0. 

view = Number(''); // returns 0
view = Number('    '); // returns 0
view = Number(null); // returns 0
view = Number([]); // returns 0

• Boolean value true converts to 1, and false converts to 0.

view = Number(false); // returns 0
view = Number(true); // returns 1

• Non-blank stings, undefined, and objects convert to NaN.

view = Number('some text'); // returns NaN
view = Number(undefined); // returns NaN
view = Number({}); // returns NaN

3. Number: static methods and properties

• So far we've seen that the Number object is a constructor function that can be used to instantiate number objects, and when called in a non-constructor context, it converts values to numbers.
• Now let's look at static methods and properties. 

ParseInt:

• We already saw that the Number function will convert strings to numbers. ParseInt is a little more specific.
• It only returns an integer. If there are any decimal points they get truncated. In the below example we pass in 1.9 we get the integer 1.

let view = Number.parseInt('1.9'); // returns 1

• Static methods are called directly on the Number class, so you chain it to Number. 
• However, there are a few static number methods that JavaScript put directly on the global object, including parseInt. So you can call parseInt without chaining it to Number. The below example calls parseInt on the value 2.9 and returns the integer 2.

view = parseInt('2.9'); // returns 2

view = parseInt('3.9 and some text'); // returns 3
view = Number('3.9 and some text'); // returns NaN

view = parseInt('This does not work 3.8'); // returns NaN

ParseFloat:

• ParseFloat parses a sting and returns a floating point number. This is actually very similar to just calling the Number function.
• In the below example the string 4.1 is parsed to the floating point number 4.1.

view = Number.parseFloat('4.1'); // returns 4.1

view = parseFloat('5.2'); // returns 5.2

view = parseFloat('6'); // returns 6

view = parseFloat('5.2 and some text'); // returns 5.2
view = Number('5.2 and some text'); // returns NaN

view = parseFloat('This does not work 5.3'); // returns NaN

Test numbers

• There are some static methods that test values and return true or false.

• IsFinite determines whether the value argument is a finite number. That means it must be of the number data type, and cannot be one of the symbolic number values Infinity, -Infinity, or NaN.

view = Number.isFinite(9999999); // returns true
view = Number.isFinite('9999999'); // returns false
view = Number.isFinite(NaN); // returns false

• IsNaN returns true if the value is the symbol value NaN and false if not.
• Passing in a string will return false. A string is not the number value NaN.
• But if you convert text to a number then it will become the value NaN, and isNaN will return true.

view = Number.isNaN('11'); // returns false
view = Number.isNaN(Number('some text')); // returns true

view = Number.isInteger(11); // returns true
view = Number.isInteger('11'); // returns false
view = Number.isInteger(11.9); // returns false

view = Number.isSafeInteger(11); // returns true
view = Number.isSafeInteger(Number.MAX_SAFE_INTEGER); // returns true
view = Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1); // returns false

view = Number.MAX_SAFE_INTEGER; // returns 9007199254740991
view = Number.MIN_SAFE_INTEGER; // returns -9007199254740991

4.  Number prototype: instance properties and methods

• All objects have an internal property called [[prototype]] whose value is a reference to the prototype object from the constructor function (i.e., class) that created it. The prototype object holds instance properties and/or methods that can be applied to the object. 
• For primitive values like numbers, the prototype is a wrapper that holds properties and methods to represent and manipulate number values.

• To find the prototype of a value call the Object.getPrototypeOf method and pass in a number value. The statement below passes in the number 7, and it returns  Number.prototype. 

let view = Object.getPrototypeOf(7); // returns Number.prototype

view = Object.getOwnPropertyNames(Number.prototype); // returns constructor, toExponential, toFixed, toPrecision, toString, valueOf, toLocaleString

Instance property

• The constructor property is a reference to the Number constructor function.

• Instance methods are methods that can be applied directly to the value. 

• If the number is an object instead of a primitive value, the valueOf method to it will return the primitive value.

let num = new Number(7);
typeof num; // returns 'object'
num = num.valueOf(); // returns 7
typeof num; // returns 'number'

• The toString method returns the number as a string value.

num = (1995.98).toString(); // returns '1995.98'

• ToFixed returns the number as a string with a fixed number of decimal points. The argument pass in the number of digits to display after the decimal point. It will round the number if needed. 

num = (1995.48).toFixed(1); // returns '1995.5'
num = (1995.48).toFixed(3); // returns '1995.480'

• ToPrecision returns the number as a string. The argument is for the total number of digits to present. It includes both sides of the decimal point. It also rounds if necessary.

num = (1995.48).toPrecision(5); // returns '1995.5'
num = (1995.48).toPrecision(7); // returns '1995.480'

• ToLocaleString returns a string with a language-sensitive representation of the number.

• Calling it without an argument will present the number based on the language setting in the user's browser. In the US it will use comma separators in the number.

num = (1995.48).toLocaleString(); // returns '1,995.48'

• The below example adds an argument for German. It returns the number as a string with the number formatting used in Germany.

num = (1995.48).toLocaleString('de-DE'); // returns '1.995,48'

• The next example sets the language to US English and adds an option to present it as US dollar currency.

num = (1995.48).toLocaleString('en-US', { style: 'currency', currency: 'USD' }); // returns '$1,995.48'

5. Math object

let view = Object.getOwnPropertyNames(Math); // returns abs, acos, acosh, asin, asinh, atan, atanh, atan2, ceil,cbrt, expm1, clz32, cos, cosh, exp, floor, fround, hypot,imul,log, log1p, log2, log10, max, min, pow, random, round, sign,sin, sinh,sqrt, tan, tanh, trunc, E, LN10,LN2, LOG10E, LOG2E, PI, SQRT1_2, SQRT2

view = Math.PI; // returns 3.141592653589793

let res = Math.round(1995.95); // returns 1996

res = Math.trunc(1995.95); // returns 1995

res = Math.floor(1995.95); // returns 1995

res = Math.ceil(1995.01); // returns 1996

res = Math.max(7, -5, 12, 0, 9); // returns 12

res = Math.min(7, -5, 12, 0, 9); // returns -5

res = Math.sqrt(81); // returns 9

res = Math.cbrt(27); // returns 3

res = Math.random(); // returns a random decimal 0.28477604336688955
res = (Math.floor(Math.random() * 10)) + 1; // returns a random integer 1-10

• That concludes this tutorial on Numbers, and the Math object.