### 1. Using parseInt()

`parseInt()`

parses a string and returns a whole number. Spaces are allowed. Only the first number is returned.

This method has a limitation though. If you parse the decimal number, it will be rounded off to the nearest integer value and that value is converted to *string*. One might need to use `parseFloat()`

method for literal conversion.

```
myString = '129'
console.log(parseInt(myString)) // expected result: 129
a = 12.22
console.log(parseInt(a)) // expected result: 12
```

### 2. Using Number()

`Number()`

can be used to convert JavaScript variables to numbers. We can use it to convert the string too number.

If the value cannot be converted to a number, `NaN`

is returned.

```
Number("10"); // returns 10
Number(" 10 "); // returns 10
Number("10.33"); // returns 10.33
```

### 3. Using Unary Operator (+)

The unary plus operator (`+`

) precedes its operand and evaluates to its operand but attempts to convert it into a number, if it isn't already.

```
const x = 25;
const y = -25;
console.log(+x); // expected output: 25
console.log(+y); // expected output: -25
console.log(+''); // expected output: 0
```

### 4. Using parseFloat()

`parseFloat()`

parses a string and returns a number. Spaces are allowed. Only the first number is returned.

```
parseFloat("10"); // returns 10
parseFloat("10.33"); // returns 10.33
parseFloat("10 20 30"); // returns 10
parseFloat("10 years"); // returns 10
parseFloat("years 10"); // returns NaN
```

### 5. Using Math.floor()

The `Math.floor()`

function returns the largest integer less than or equal to a given number. This can be little tricky with decimal numbers since it will return the value of the nearest integer as *Number*.

```
str = '1222'
console.log(Math.floor(str)) // returns 1222
a = 12.22
Math.floor(a) // expected result: 12
```

### 6. Multiply with number

Multiplying the string value with the `1`

which won’t change the value and also it will be converted to number by default.

```
str = '2344'
console.log(str * 1) // expected result: 2344
```

### 7. Double tilde (~~) Operator

We can use the *double tilde* operator to convert the string to number.

```
str = '1234'
console.log(~~str) // expected result: 1234
negStr = '-234'
console.log(~~negStr) // expected result: -234
```

Here is the comparison of the ways mentioned performance wise. Comment below if you know more methods.

Thank You

## Top comments (19)

The double tilde method is actually something I never thought about, but is worth explaining.

The double tilde "operator" is not as much as an operator as it's a double

bitwise negation.Let's cast

`'64'`

to`64`

using this method, so we do`~~'64'`

. First we will evaluate`~'64'`

. As bitwise operations work on binary,`'64'`

is cast to a number. So`~64`

.`64`

in binary is`01000000`

.`~`

will negate all the bits so it becomes`10111111`

, which is`-65`

since numbers in JavaScript are signed. Now we negate it again, which becomes`01000000`

, which is`64`

in decimal.Correction:I previously stated that

`10111111`

is`-63`

, which is incorrect. It's actually`-65`

. Sorry about that.Thanks for explaining this. When I got to that one, I was wondering what it was. Great explanation.

Thank you. This was informative. I didn't pay attention about how it works while writing. Will note it down.

In the first paragraph "If you parse the decimal number, it will be rounded off to the nearest integer value and that value is converted to string. " I think it should say "that value is converted to a number".

This is a really helpful article! As a beginner in JavaScript, I often find myself struggling with converting strings to numbers. It's great to see all these different methods laid out with examples for each one. I especially appreciated the explanation of the parseFloat() function and the caution against using the unary plus operator on strings that could be mistaken for numbers. Thank you for sharing!

FitGAGYou should always pass the base as second argument to

`parseInt`

.thanks for the info.

how would we go about converting a 19 digit string to a number , js behaves very weirdly for that

e.g lets say this is the number 6145390195186705543 and want to convert it into number what it gives me is this 6145390195186705000. not sure why

Noice

thanks

Great explanation.

Thanks! 🥰💖

Using

`x - 0`

works, tooFor the string that includes comma (VD: '1,234.44'), you can use parseNumber function to avoid the further bug

nice info. some time forget about this and using lib js

I like the

Using parseInt()method for generating numbers.mbox converter

Thanks for the info dude,

Many thanks for this!