# The global object
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`
and the functions are
* `decodeURI()`
* `decodeURIComponent()`
* `encodeURI()`
* `encodeURIComponent()`
* `eval()`
* `isFinite()`
* `isNaN()`
* `parseFloat()`
* `parseInt()`
The objects are the ones you already saw before, which are part of the standard library:
* `Array`
* `Boolean`
* `Date`
* `Function`
* `JSON`
* `Math`
* `Number`
* `Object`
* `RegExp`
* `String`
* `Symbol`
and errors.
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.
```jsx
parseInt() //NaN
parseInt('a') //NaN
0/0 //NaN
```
A special thing to consider is that a `NaN` value is ever equal to another `NaN` value. You must use the `isNaN()` global function to check if a value evaluates to `NaN`:
```jsx
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`:
```jsx
const test = () => {}
test() //undefined
```
Unlike `NaN`, we can compare an `undefined` value with `undefined`, and get true:
```jsx
undefined === undefined
```
It’s common to use the `typeof` operator to determine if a variable is undefined:
```jsx
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:
```jsx
encodeURI("http://flaviocopes.com/ test/")
//'http://flaviocopes.com/%20test/'
```
### `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:
```jsx
encodeURIComponent("http://flaviocopes.com/ test/")
//'http%3A%2F%2Fflaviocopes.com%2F%20test%2F'
```
### `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](http://2ality.com/2014/01/eval.html) on the subject.
### `isFinite()`
Returns true if the value passed as parameter is finite.
```jsx
isFinite(1) //true
isFinite(Number.POSITIVE_INFINITY) //false
isFinite(Infinity) //false
```
### `isNaN()`
Returns true if the value passed as parameter evaluates to `NaN`.
```jsx
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`:
```jsx
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:
```jsx
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:
```jsx
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:
```jsx
parseInt('10 lions', 10) //10
```
but if the string does not start with a number, you’ll get `NaN` (Not a Number):
```jsx
parseInt("I'm 10", 10) //NaN
```
Also, just like Number it’s not reliable with separators between the digits:
```jsx
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 ✅
```
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://docs.bashschool.in/v1/javascript/basics/built-in-objects/the-global-object.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.