In this tutorial, we will talk about the `parseInt`

function in JavaScript. This function parses (break down) a string and returns an integer or `NaN`

(Not a Number).

## How the `parseInt`

function works

The main purpose of using the `parseInt`

function is to extract a number from a string. This turns the returned value to an actual number.

Here is the syntax:

`parseInt(string)`

Consider the example below:

```
const myNumber = '3';
console.log(2 + myNumber);
// returns 23
```

In the example above, 3 is a string and not an actual number. When we add 2 to the string, we are given 23 because we are just adding 2 to a string that is just in the form of a number.

With the `parseInt`

function, we can can extract 3 from the string and turn it to an actual number. Here is an example:

```
const myNumber = '3';
console.log(2 + parseInt(myNumber));
// returns 5
```

Now the function has removed 3 from the string and converted it to an actual number.

From '3' to 3.

Recall that we said that the `parseInt`

function can either return an integer or `NaN`

. So when would we get a `NaN`

value?

This happens when we have some text before a number in a string. Something like "age is 50" will return a `NaN`

value because the `parseInt`

function only looks at the first value starting the string. If the value is not a number, `NaN`

is returned. Here:

```
const age = 'age is 50';
console.log(parseInt(age));
// returns NaN
```

Let's rearrange the string and see what happens.

```
const age = '50 is the age';
console.log(parseInt(age));
// returns 50
```

Now the first value in the string is a number and that number is returned to us.

Note that the `parseInt`

function ignores float values. If the age above was 50.05 then it would still return 50 and ignore .05.

In the same manner, if we had a string like this: "50 100 150 200" then we'd only get 50 returned to us. This is because the `parseInt`

function only attempts to extract the first value of a string.

And if the string had its values written together like this: '50istheage', 50 would still be returned.

## The `radix`

parameter

The `parseInt`

function accepts a second parameter known as `radix`

. This parameter specifies what number system to use. If the radix is omitted then 10 is taken as the default.

Here is the syntax:

`parseInt(string, radix)`

This is usually an integer between 2 and 36. If the value of the radix is less than 2 or greater than 36 then `NaN`

is returned.

If we were to specify a radix of 12 then it implies that the number in the string should be parsed from the duodecimal value of the number to its decimal value.

Here is a quick example:

```
console.log(parseInt("50", 12));
// returns 60
```

We get 12 returned because the duodecimal value of 50 in base 10 (decimal) is 60.

## Conclusion

In this tutorial, we learned how to use the `parseInt`

function to extract numbers from strings.

We also saw how we could use the `radix`

parameter to specify what number system to be used when converting our returned integer.

Thank you for reading!