## DEV Community is a community of 700,720 amazing developers

We're a place where coders share, stay up-to-date and grow their careers. # 7 ways to convert a String to Number in JavaScript Sanchithasr
Web developer

### 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

## Discussion (5) RVxLab • Edited

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.  