# JavaScript Numbers Unlike other programming languages in JavaScript, we only have one type ``` number ``` that represents all the numbers including integers, floats, real, decimal as well as complex. We can either use decimal points or simple integers to represent a number.

Example

```let a = 20;  // number without decimal
let b = 20.1;  // number with decimal```

To represent a very small or big number we can use the exponent notation in JavaScript.

```let l = 21e6;     // 21*1000000
let s = 21e-6;    // 21/1000000
```

The ``` e ``` suffix after the number represents the exponent power.

## JavaScript 64-bit Floating Points Number

Unlike other programming languages, we do not get dedicated keywords to represent float, integer, short, decimal, or double numbers in JavaScript. JS follows the international IEEE754 Standard to store all the numbers as double-precision floating-point numbers. According to the format JS use 64 bits to store a number, out 0f 64 bits 0 to 51 bits assigned to the number or fraction part, 52 to 62 bits allocated to the exponent part and 63 bit allocated tot the sign.

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

If we talk about the precision of numbers represented by JavaScript, JS only precise the numbers with or without decimals accurately that are 15 digits long.

Example

```let a = 999999999999999;   // 999999999999999
let b = 9999999999999999;   // 10000000000000000
let c = 1.999999999999999;    //  1.999999999999999
let d = 1.9999999999999999;  //   2
```

If a number contains more than 15 digits, JS will not be able to maintain the number precision.

## JavaScript Numbers with String

JS numbers show a very unique nature when operating them with JavaScript string. The JS engine takes care of all the implicit type conversions and returns an appropriate result.

The ``` + ``` operator can be used to add two numbers or concatenate two strings. But if we use the + operator between a number and a string then it will convert the number into a string and concatenate them.

Example

```let a = 20; // number
let b = "21"; // string
let c = a + b;   // 2021 string
```

Whenever we use the number with string along with ``` + ``` operator, it will always treat the number as a string and perform the concatenate operation, not addition.

Example

```let a = 20; // number
let b = 20; // number
let c = "Concatenate a + b " + a+b;  // "Concatenate a + b 2020"
```

In the above example both ``` a ``` and ``` b ``` were numbers still the + operator performs the concatenation operation, not added because the statement before a+b was a string so the JS engine converts the complete statement as a string. Let's say you do not want to perform concatenation when both the variables are numbers and the rest of the statement is a string, there we can use the brackets, so the interpreter first executes the bracket and all of its operations then, the rest statement.

```let a = 20; // number
let b = 20; // number
let c = "Concatenate a + b " + (a+b);  //"Concatenate a + b40"
```

### Other Arithmetic operation between string and numbers

Only the ``` + ``` operator performs the concatenation operation between the string and a number, by implicit conversion of the number to a string. For the rest of the JS arithmetic operators, the JS interpreter converts the string into a corresponding integer and performs the arithmetic operation.

Example

```let a = 20;   //number
let b ="2"; // string
let mul = a*b;   //40  (number)
let div = a/b;   //10 (number)
let modu = a%b;   // 0 (number)
let sub = a-b;    // 18 (number)```

Even if we apply the arithmetic operators (except +) between two string numeric values, first both the string values will be converted into numbers and computed according to the operation.

```let a = "20";   //string
let b ="2"; // string
let mul = a*b; //40 (number)
let div = a/b; //10 (number)
let modu = a%b; // 0 (number)
let sub = a-b; // 18 (number)```

### JavaScript NaN

``` NaN ``` in JavaScript is a reserved keyword to represent Not a Number. NaN is generally used to indicate illegal number operations such as when we perform arithmetic operations between a non-numeric string and a number. Example

```let a = 20;  // number
let b = "twenty";   // string
let c = a*b;   // NaN
```

Unlike other programming languages, JS does not throw an ``` TypeError ``` when we perform an arithmetic operation between a number and string or string and string, instead, it returns a new value NaN representing Not a Number. Example

```let a = "one";   // string
let b = "two";    // string
let c = a*b;     //NaN```

### JavaScript Infinity

JavaScript provides a dedicated ``` Infinity ``` keyword to represent an infinite number. The Infinite number can be positive ``` Infinity ``` or negative ``` -Infinity ``` . Because of this keyword, we do not have ZeroDivision Error in JavaScript. Example

```let a = Infinity;
let b = 20;
let c = a+b;    // Infinity```

Example

```let a = 20;
let b = 0;
let c = a/b; // Infinity```

In JavaScript, we also represent numbers in HexaDecimal format. To create a HexaDecimal number we can use the ``` 0x ``` prefix followed by the HexaDecimal representation of a number.

Example

`let hex = 0xAB;   // 171`

### JavaScript Number Objects

By far we have been declaring or defining numbers as a primitive data type, but JavaScript also provides a built-in ``` Number() ``` object, which can also be used to represent the Number data type.

Example

```let p_num = 200; // 200 primitive data type
let o_num = new Number(200); // 200 Object number```

In the above example both ``` p_num ``` and ``` o_num ``` represent the same value, and both can perform most of the similar tasks. But it always suggests using the primitive number data type unless you know why you are using the ``` Number() ``` object.

## Summary

• Numbers are used to representing numeric values.
• Number support all the arithmetic operations.
• + operator performs the contamination operation between string-number and string-string.
• NaN is a Not a Number value that represents illegal numbers.
• Infinity and -Infinity represent the largest and smallest numbers.
• Number() objects can also be used to represent numbers.