Object-Oriented JavaScript — Numbers
Tags: webdev, programming, javascript, beginners
Published: 2021-01-24 21:49:56

**Check out my books on Amazon at https://www.amazon.com/John-Au-Yeung/e/B08FT5NT62**

**Subscribe to my email list now at http://jauyeung.net/subscribe/**


JavaScript is partly an object-oriented language.

To learn JavaScript, we got to learn the object-oriented parts of JavaScript.

In this article, we’ll look at the building blocks of objects, which are primitive values.

### Primitive Data Types

JavaScript has a few primitive data types.

They’re numbers, strings, booleans, `undefined` , `null` , and bigints.

Numbers are floating-point numbers and integers.

Strings are any group of characters.

Booleans are either `true` or `false` .

`undefined` is a value that doesn’t exist.

`null` represents an empty value.

Bigints are integers that end with an `n` and can be outside of the safe range, which is between `-2 ** 53` and `2 ** 53` .

Any value that isn’t these types are objects.

### Finding Out the Value Type

We can find the value of a primitive value with the `typeof` operator.

`typeof` can return `'number'` . `'string'` , `'boolean'` , `'undefined'` , `'object'` or `'function'` .

Numbers are one of the types that can be detected with `typeof` .

#### Number

For instance, we can write:

```
let n = 1;
typeof n;
```

and we’ll get `'number'` .

#### Octal and Hex Numbers

Octal and hexadecimal numbers also returns `'number'` .

For instance, we can write:

```
let n = 0o377;
typeof n;
```

to write an octal number and check its type.

To check a hex number, we can write:

```
let n = 0x00;
typeof n;
```

That will also return `'number'` .

#### Binary Numbers

We can also write binary literals with the `0b` prefix,.

For instance, we can write:

```
let n = 0b111;
```

#### Exponents

Exponents can be written with `e` .

For instance, we can write:

```
1e1
```

and get 10.

If we pass it to `typeof` , we get `'number'` :

```
typeof 1e1
```

#### Infinity

Infinity is another kind of number.

It’s a number too big for JavaScript to handle.

`Infinity` is a number, so if we write:

```
typeof Infinity
```

we get `'number'` .

Dividing by 0 gives us infinity. For instance, if we write:

```
let a = 1 / 0
```

then `a` is `Infinity` .

The smallest number is `-Infinity` .

When we have:

```
Infinity - Infinity
```

or

```
- Infinity + Infinity
```

we get `NaN` since they are indeterminate in their value.

But everything else gives us `Infinity` or `-Infinity` .

For instance, we can write:

```
Infinity - 20
```

we get `Infinity` .

If we write:

```
-Infinity * 3
```

we get `-Infinity` .

There’s a global `isFinite` function to check is a number is finite or not.

ES6 also adds the `Number.isFinite` to do the same check.

The difference is that the global `isFinite` function casts the value before it does the check.

And `Number.isFinite` doesn’t do that.

#### NaN

`NaN` stands for not a number.

It’s a special value that’s also a number.

If we write:

```
typeof NaN
```

we get `'number'` .

When we do some arithmetic with non-number values, then we get `NaN` .

For example, if we have:

```
let a = 10 * "a"
```

We get `NaN` .

We can check if a value is `NaN` with the `Number.isNaN` method.

There’s also the global `isNaN` method.

The difference is that the global one does casting and the non-global one doesn’t.

So:

```
Number.isNaN('test')
```

returns `false` but

```
Number.isNaN(NaN)
```

returns `true` .

`Number.isInteger` is a method that checks if a value is a finite integer.

For instance, if we have:

```
Number.isInteger(123)
```

then that returns `true` .

But if we have:

```
Number.isInteger('foo')
```

that returns `false` .

It doesn’t do casting before it does the comparison.

### Conclusion

There are various kinds of primitive values in JavaScript.

One of them is a number.

There’re various representations of numbers.