# How To Convert String To Number In JavaScript

In this blog post, we will explore different ways to convert a string to a number in JavaScript. This is a common programming task, and understanding how to do it efficiently and correctly is an important skill for any programmer, especially those new to the language.

Imagine you are working on a web application, and you want to perform some arithmetic operations on user input. The user input is usually in the form of a string (a sequence of characters), but you need to convert it into a number to perform calculations. This is where converting a string to a number comes in handy.

We will cover the following methods for converting strings to numbers in JavaScript: 1. Number() 2. parseInt() 3. parseFloat() 4. Unary plus (+) 5. Multiply by 1

Let's dive into each of these methods.

## 1. Number()

The `Number()`

function is a built-in global function in JavaScript that can be used to convert different data types, like strings, into numbers. If the conversion is successful, it returns a number; otherwise, it returns NaN (which stands for "Not a Number").

Here's an example:

```
let string = "42";
let number = Number(string);
console.log(number); // Output: 42
```

In this example, we have a string "42" which is successfully converted to the number 42 using the `Number()`

function.

However, if the string cannot be converted to a number, Number() will return NaN:

```
let string = "hello";
let number = Number(string);
console.log(number); // Output: NaN
```

In this case, the string "hello" cannot be converted to a number, so the function returns NaN.

## 2. parseInt()

The `parseInt()`

function is another built-in global function in JavaScript that can be used to convert a string to an integer (a whole number). It takes two arguments: the first is the string to be converted, and the second is the radix (the base of the number system). The radix is optional and defaults to 10 if not provided.

Here's an example:

```
let string = "42.5";
let number = parseInt(string);
console.log(number); // Output: 42
```

In this example, the string "42.5" is converted to the integer 42 using the `parseInt()`

function. Note that the decimal part is discarded during the conversion.

The parseInt() function can also handle strings with non-numeric characters at the beginning or the end:

```
let string = " 42px";
let number = parseInt(string);
console.log(number); // Output: 42
```

In this case, the function successfully converts the string " 42px" to the integer 42, ignoring the white spaces and the "px" at the end.

## 3. parseFloat()

The `parseFloat()`

function is another built-in global function in JavaScript that can be used to convert a string to a floating-point number (a number with decimal places). It takes only one argument, the string to be converted.

Here's an example:

```
let string = "42.5";
let number = parseFloat(string);
console.log(number); // Output: 42.5
```

In this example, the string "42.5" is successfully converted to the floating-point number 42.5 using the `parseFloat()`

function.

Similar to the `parseInt()`

function, the `parseFloat()`

function can also handle strings with non-numeric characters at the beginning or the end:

```
let string = " 42.5px";
let number = parseFloat(string);
console.log(number); // Output: 42.5
```

In this case, the function successfully converts the string " 42.5px" to the floating-point number 42.5, ignoring the white spaces and the "px" at the end.

## 4. Unary plus (+)

The unary plus (+) operator is a lesser-known method for converting a string to a number in JavaScript. It is a shorthand way to achieve the same result as using the `Number()`

function.

Here's an example:

```
let string = "42";
let number = +string;
console.log(number); // Output: 42
```

In this example, the unary plus (+) operator is used to convert the string "42" to the number 42.

If the string cannot be converted to a number, the unary plus (+) operator will return NaN:

```
let string = "hello";
let number = +string;
console.log(number); // Output: NaN
```

In this case, the unary plus (+) operator returns NaN since the string "hello" cannot be converted to a number.

## 5. Multiply by 1

Another way to convert a string to a number in JavaScript is to multiply the string by 1. This method works because JavaScript performs type coercion (automatic conversion between data types) during arithmetic operations.

Here's an example:

```
let string = "42";
let number = string * 1;
console.log(number); // Output: 42
```

In this example, the string "42" is successfully converted to the number 42 by multiplying it by 1.

Similar to the unary plus (+) operator, if the string cannot be converted to a number, multiplying it by 1 will return NaN:

```
let string = "hello";
let number = string * 1;
console.log(number); // Output: NaN
```

In this case, the result is NaN since the string "hello" cannot be converted to a number.

## Conclusion

In this blog post, we discussed five different ways to convert a string to a number in JavaScript. Each method has its own advantages and use cases, so it's essential to understand how they work and when to use them.

For most situations, the `Number()`

, `parseInt()`

, or `parseFloat()`

functions are recommended as they provide more control and clarity. The unary plus (+) operator and multiplying by 1 can be useful in certain cases as shorthand methods, but they might be less readable for beginners.

As you continue learning and growing as a programmer, it's crucial to understand these conversion methods to make your code efficient and avoid potential bugs or errors. Happy coding!