The details of the Global object in JavaScript

JavaScript provides a **global object** which has a set of properties, functions and objects that are accessed globally, without a namespace.

The properties are:

`Infinity`

`NaN`

`undefined`

The functions are:

`decodeURI()`

`decodeURIComponent()`

`encodeURI()`

`encodeURIComponent()`

`eval()`

`isFinite()`

`isNaN()`

`parseFloat()`

`parseInt()`

These are the objects:

and errors:

`Error`

`EvalError`

`RangeError`

`ReferenceError`

`SyntaxError`

`TypeError`

`URIError`

I describe errors on this JavaScript Errors reference post.

Let’s now describe here the global properties and functions.

`Infinity`

`Infinity`

in JavaScript is a value that represents **infinity**.

Positive infinity. To get negative infinity, use the `–`

operator: `-Infinity`

.

Those are equivalent to `Number.POSITIVE_INFINITY`

and `Number.NEGATIVE_INFINITY`

.

Adding any number to `Infinity`

, or multiplying `Infinity`

for any number, still gives `Infinity`

.

`NaN`

The global `NaN`

value is an acronym for `Not a Number`

. It’s returned by operations such as zero divided by zero, invalid parseInt() operations, or other operations.

```
parseInt() //NaN
parseInt('a') //NaN
0/0 //NaN
```

A special thing to consider is that a `NaN`

value is never equal to another `NaN`

value. You must use the `isNaN()`

global function to check if a value evaluates to `NaN`

:

```
NaN === NaN //false
0/0 === NaN //false
isNaN(0/0) //true
```

`undefined`

The global `undefined`

property holds the primitive value `undefined`

.

Running a function that does not specify a return value returns `undefined`

:

```
const test = () => {}
test() //undefined
```

Unlike `NaN`

, we can compare an `undefined`

value with `undefined`

, and get true:

`undefined === undefined`

It’s common to use the `typeof`

operator to determine if a variable is undefined:

```
if (typeof dog === 'undefined') {
}
```

`decodeURI()`

Performs the opposite operation of `encodeURI()`

`decodeURIComponent()`

Performs the opposite operation of `encodeURIComponent()`

`encodeURI()`

This function is used to encode a complete URL. It does encode all characters to their HTML entities except the ones that have a special meaning in a URI structure, including all characters and digits, plus those special characters:

`~!@#$&*()=:/,;?+-_.`

Example:

```
encodeURI("http://flaviocopes.com/ hey!/")
//"http://flaviocopes.com/%20hey!/"
```

`encodeURIComponent()`

Similar to `encodeURI()`

, `encodeURIComponent()`

is meant to have a different job.

Instead of being used to encode an entire URI, it encodes a portion of a URI.

It does encode all characters to their HTML entities except the ones that have a special meaning in a URI structure, including all characters and digits, plus those special characters:

`-_.!~*'()`

Example:

```
encodeURIComponent("http://www.example.org/a file with spaces.html")
// "http%3A%2F%2Fwww.example.org%2Fa%20file%20with%20spaces.html"
```

`eval()`

This is a special function that takes a string that contains JavaScript code, and evaluates / runs it.

This function is very rarely used and for a reason: it can be dangerous.

I recommend to read this article on the subject.

`isFinite()`

Returns true if the value passed as parameter is finite.

```
isFinite(1) //true
isFinite(Number.POSITIVE_INFINITY) //false
isFinite(Infinity) //false
```

`isNaN()`

Returns true if the value passed as parameter evaluates to `NaN`

.

```
isNaN(NaN) //true
isNaN(Number.NaN) //true
isNaN('x') //true
isNaN(2) //false
isNaN(undefined) //true
```

This function is very useful because a `NaN`

value is never equal to another `NaN`

value. You must use the `isNaN()`

global function to check if a value evaluates to `NaN`

:

```
0/0 === NaN //false
isNaN(0/0) //true
```

`parseFloat()`

Like `parseInt()`

, `parseFloat()`

is used to convert a string value into a number, but retains the decimal part:

```
parseFloat('10,000', 10) //10 ❌
parseFloat('10.00', 10) //10 ✅ (considered decimals, cut)
parseFloat('10.000', 10) //10 ✅ (considered decimals, cut)
parseFloat('10.20', 10) //10.2 ✅ (considered decimals)
parseFloat('10.81', 10) //10.81 ✅ (considered decimals)
parseFloat('10000', 10) //10000 ✅
```

`parseInt()`

This function is used to convert a string value into a number.

Another good solution for integers is to call the `parseInt()`

function:

`const count = parseInt('1234', 10) //1234`

Don’t forget the second parameter, which is the radix, always 10 for decimal numbers, or the conversion might try to guess the radix and give unexpected results.

`parseInt()`

tries to get a number from a string that does not only contain a number:

`parseInt('10 lions', 10) //10`

but if the string does not start with a number, you’ll get `NaN`

(Not a Number):

`parseInt("I'm 10", 10) //NaN`

Also, just like Number it’s not reliable with separators between the digits:

```
parseInt('10,000', 10) //10 ❌
parseInt('10.00', 10) //10 ✅ (considered decimals, cut)
parseInt('10.000', 10) //10 ✅ (considered decimals, cut)
parseInt('10.20', 10) //10 ✅ (considered decimals, cut)
parseInt('10.81', 10) //10 ✅ (considered decimals, cut)
parseInt('10000', 10) //10000 ✅
```