## Math.sqrt i.e sqrt is a part of Math namespace.

// 2 ways to get square root.

Math.sqrt(100); // 10, Method 1

100**(1/2); // 10, Method 2
8**(1/3); // 2, works for cubic root also

## Math.max() & Math.min():

Math.max(23,54,12,6,32,98,87,34,11); // 98

// Does type coercion also

Math.min(23,54,12,'6',32,98,87,34,11); // 6

// Does not do parsing

Math.min(23,54,12,'6px',32,98,87,34,11); // NaN

## Inbuilt constants on Math object:

Math.PI * (Number.parseFloat('10px')**(2)); // Getting area

## Generate a no b/w 1-6:

Math.trunc(Math.random() * 6) + 1;

## Generatate a random no b/w an upper-lower limit:

const randomInt = (min, max) => Math.floor(Math.random() * (max-min)) + 1 + min;

randomInt(10,20);

// All of these Math.method() do type coercion.

Math.trunc(25.4); // 25

Math.round(25.4); // 25

Math.floor(25.4); // 25

Math.ceil(25.4); // 26

## Math.floor is a better choice for negative numbers.

Math.trunc(-25.4); // -25

Math.floor(-25.4); // -26

// Rounding decimals: .toFixed returns a string, not a number

(2.5).toFixed(0); // '3'

(2.5).toFixed(3); // '2.500'

(2.345).toFixed(2); // '2.35'

// Add a unary + sign to convert it to a no.

+(2.345).toFixed(2); // 2.35

// Number is a primitive, hence they don't have methods. SO behind the scene, JS will do boxing, i.e transform primitive into a no object, perform the operation and then when operation is finished, transform it back to primitive.

## Modular or Remainder Operator:

5 % 2; // 1

8 % 3; // 2

8 / 3; // 2.6666666666666665

// Odd or Even

const isEven = n => n%2 === 0;

isEven(20);

isEven(21);

isEven(22);

Usecase: Used to work with all odd rows, even rows, nth time etc.

## Numeric Separators: [ES2021]

Used for representing really large numbers

These are underscores which can be placed between numbers. The engine ignores these underscores, its reduces the confusion for devs.

Ex. const diameter = 287_460_000_000;

diameter; // 287460000000

const price = 342_25;

price; // 34225

const fee1 = 1_500;

const fee2 = 15_00;

fee1 === fee2; // true

Underscore can be placed ONLY between numbers.

It cannot be placed adjacent to a dot of decimal.

It also cannot be placed at the begining or the end of the no.

const PI = 3.14_15;

PI; // 3.1415

## All are invalid example of numeric separators

const PI = *3.1415; // Cannot be placed in the begining.
const PI = 3.1415*; // Cannot be placed in the end.

const PI = 3_.1415; // Cannot be placed adjacent to a decimal dot.

const PI = 3.

*1415; // Cannot be placed adjacent to a decimal dot.*

const PI = 3._1415; // Two in a row cannot be placed.

const PI = 3.

## Converting Strings to Numbers:

Number('2500'); // 2500

Number('25_00'); // NaN , Hence we can only use when directly numbers are assigned to a variable. Hence, if a no is stored in the string or getting a no from an API, then to avoid error don't use '_' numeric separator.

Similar goes for parseInt i.e anything after _ is discarded as shown below:

parseInt('25_00'); // 25

## BigInt

Special type of integers, introduced in ES2020

Numbers are represented internally as 64 bits i.e 64 1s or 0s to represent any number. Only 53 are used to store the digits, remaining are used to store the position of decimal point and the sign. Hence, there is a limit on the size of the number i.e ((2**53) - 1). This is the biggest no which JS can safely represent. The base is 2, because we are working in binary form while storing.
2**53 - 1; // 9007199254740991

Number.MAX_SAFE_INTEGER; // 9007199254740991

Anything larger than this is not safe i.e it cannot be represented accurately. Precision will be lost for numbers larger than this as shown in last digit. Sometimes it might work, whereas sometimes it won't.

Number.MAX_SAFE_INTEGER + 1; // 9007199254740992

Number.MAX_SAFE_INTEGER + 2; // 9007199254740992

Number.MAX_SAFE_INTEGER + 3; // 9007199254740994

Number.MAX_SAFE_INTEGER + 4; // 9007199254740996

Incase we get a larger no from an API larger than this, then JS won't be able to deal with it. So to resolve the above issue, BigInt a new primitive data type was introduces in ES2020. This can store integers as large as we want.

An 'n' is added at the end of the no to make it a BigInt. Ex.

const num = 283891738917391283734234324223122313243249821n;

num; // 283891738917391283734234324223122313243249821n

BigInt is JS way of displaying such huge numbers.

Another way using Constructor Fn for creating BigInt number.

const x = BigInt(283891738917391283734234324223122313243249821);

x; // 283891738917391288062871194223849945790676992n

Operations: All arithmetic operators work the same with BigInt;

const x = 100n + 100n;

x; // 200n

const x = 10n * 10n;

x; // 100n

## Avoid mixing BigInt numbers with regular numbers

const x = 100n;

const y = 10;

z = x*y; // Error

To make it work, use BigInt constructor Fn:

z = x * BigInt(y);

z; // 1000n

## Exception to it are comparsion operators & unary + operator.

20n > 19; // true

20n === 20; // false, === prevents JS from doing type coercion. Both the LHS & RHS have different primitive types, hence results in 'false'.

typeof 20n; // 'bigint'

typeof 20; // 'number'

20n == 20; // true, as JS does type coercion to compare only the values and not the types by converting BigInt to a regular number.

Same goes for this also: 20n == '20'; // true

## Exception:

BigInt number is not converted to string on using + operator.

const num = 248923874328974239473829n

"num is huge i.e. " + num; // 'num is huge i.e. 248923874328974239473829'

Note:

Math.sqrt doesn't work with BigInt.

During division of BigInts, it discards the decimal part.

10 / 3; // 3.3333333333333335

10n / 3n; // 3n

12n / 3n; // 4n

This new primitive type adds some new capabilities to JS language to make it work with huge no.

## Top comments (0)