Nu

# Numbers in  9 exercises

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.

• `number`: a numeric data type in the double-precision 64-bit floating-point format (IEEE 754). Examples are `-6`, `-2.4`, `0`, `0.1`, `1`, `3.14`, `16.984025`, `25`, `976`, `1024.0` and `500000`.
• `bigint`: a numeric data type that can represent integers in the arbitrary precision format. Examples are `-12n`, `0n`, `4n`, and `9007199254740991n`.
``````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:

• `VALUE`: given by `Number.MAX_VALUE` and `Number.MIN_VALUE`
• `INFINITY`: given by `Number.POSITIVE_INFINITY` and `Number.NEGATIVE_INFINITY`
• `SAFE_INTEGER`: given by `Number.MAX_SAFE_INTEGER` and `Number.MIN_SAFE_INTEGER`

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:

• Two error values, `NaN` and `Infinity`.
• Two values for zero, `+0` and `-0`.

#### NaN - Not a Number

The error value `NaN`(aka "Not a Number") is produced in the following cases.

• A number could not be parsed:
``````Number('123'); // => 123
Number('Hello, World!'); // => NaN
``````
• An operation failed:
``````Math.sqrt(-64); // => NaN
``````
• One of the operands is NaN:
``````NaN + 69; // => NaN
``````

`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:

• A number can't be represented because its magnitude is too large.
``````Math.pow(2, 1024); // => Infinity
``````
• A division by zero has happened.
``````6 / 0; // => Infinity
-6 / 0; // => -Infinity
``````

`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. Edit via GitHub 