How do I convert a string to an integer in JavaScript?

The simplest way would be to use the native `Number`

function:

```
var x = Number("1000")
```

If that doesn't work for you, then there are the **parseInt**, **unary plus**, **parseFloat with floor**, and **Math.round** methods.

parseInt:

```
var x = parseInt("1000", 10); // you want to use radix 10
// so you get a decimal number even with a leading 0 and an old browser ([IE8, Firefox 20, Chrome 22 and older][1])
```

unary plus if your string is already in the form of an integer:

```
var x = +"1000";
```

if your string is or might be a float and you want an integer:

```
var x = Math.floor("1000.01"); //floor automatically converts string to number
```

or, if you're going to be using Math.floor several times:

```
var floor = Math.floor;
var x = floor("1000.01");
```

If you're the type who forgets to put the radix in when you call parseInt, you can use parseFloat and round it however you like. Here I use floor.

```
var floor = Math.floor;
var x = floor(parseFloat("1000.01"));
```

Interestingly, Math.round (like Math.floor) will do a string to number conversion, so if you want the number rounded (or if you have an integer in the string), this is a great way, maybe my favorite:

```
var round = Math.round;
var x = round("1000"); //equivalent to round("1000",0)
```

Try parseInt function:

```
var number = parseInt("10");
```

But there is a problem. If you try to convert "010" using parseInt function, it detects as octal number, and will return number 8. So, you need to specify a radix (from 2 to 36). In this case base 10.

```
parseInt(string, radix)
```

Example:

```
var result = parseInt("010", 10) == 10; // Returns true
var result = parseInt("010") == 10; // Returns false
```

Note that `parseInt`

ignores bad data after parsing anything valid.

This guid will parse as 51:

```
var result = parseInt('51e3daf6-b521-446a-9f5b-a1bb4d8bac36', 10) == 51; // Returns true
```

There are two main ways to convert a string to a number in javascript. One way is to parse it and the other way is to change its type to a Number. All of the tricks in the other answers (e.g. unary plus) involve implicitly coercing the type of the string to a number. You can also do the same thing explicitly with the Number function.

**Parsing**

```
var parsed = parseInt("97", 10);
```

parseInt and parseFloat are the two functions used for parsing strings to numbers. Parsing will stop silently if it hits a character it doesn't recognise, which can be useful for parsing strings like "92px", but it's also somewhat dangerous, since it won't give you any kind of error on bad input, instead you'll get back NaN unless the string starts with a number. Whitespace at the beginning of the string is ignored. Here's an example of it doing something different to what you want, and giving no indication that anything went wrong:

```
var widgetsSold = parseInt("97,800", 10); // widgetsSold is now 97
```

It's good practice to always specify the radix as the second argument. In older browsers, if the string started with a 0, it would be interpreted as octal if the radix wasn't specified which took a lot of people by surprise. The behaviour for hexadecimal is triggered by having the string start with 0x if no radix is specified, e.g. `0xff`

. The standard actually changed with ecmascript 5, so modern browsers no longer trigger octal when there's a leading 0 if no radix has been specified. parseInt understands radixes up to base 36, in which case both upper and lower case letters are treated as equivalent.

**Changing the Type of a String to a Number**

All of the other tricks mentioned above that don't use parseInt, involve implicitly coercing the string into a number. I prefer to do this explicitly,

```
var cast = Number("97");
```

This has different behavior to the parse methods (although it still ignores whitespace). It's more strict: if it doesn't understand the whole of the string than it returns `NaN`

, so you can't use it for strings like `97px`

. Since you want a primitive number rather than a Number wrapper object, make sure you don't put `new`

in front of the Number function.

Obviously, converting to a Number gives you a value that might be a float rather than an integer, so if you want an integer, you need to modify it. There are a few ways of doing this:

```
var rounded = Math.floor(Number("97.654")); // other options are Math.ceil, Math.round
var fixed = Number("97.654").toFixed(0); // rounded rather than truncated
var bitwised = Number("97.654")|0; // do not use for large numbers
```

Any bitwise operator (here I've done a bitwise or, but you could also do double negation as in an earlier answer or a bitshift) will convert the value to a 32bit integer, and most of them will convert to a signed integer. Note that this **will not do want you want for large integers**. If the integer cannot be represented in 32bits, it will wrap.

```
~~"3000000000.654" === -1294967296
// This is the same as
Number("3000000000.654")|0
"3000000000.654" >>> 0 === 3000000000 // unsigned right shift gives you an extra bit
"300000000000.654" >>> 0 === 3647256576 // but still fails with larger numbers
```

To work correctly with larger numbers, you should use the rounding methods

```
Math.floor("3000000000.654") === 3000000000
// This is the same as
Math.floor(Number("3000000000.654"))
```

Bear in mind that all of these methods understand exponential notation, so `2e2`

is `200`

rather than NaN. Also, Number understands "Infinity", while the parse methods don't.

**Custom**

It's unlikely that either of these methods do exactly what you want. For example, usually I would want an error thrown if parsing fails, and I don't need support for Infinity, exponentials or leading whitespace. Depending on your usecase, sometimes it makes sense to write a custom conversion function.

Always check that the output of Number or one of the parse methods is the sort of number you expect. You will almost certainly want to use `isNaN`

to make sure the number is not NaN (usually the only way you find out that the parse failed).

ParseInt() and + are different

```
parseInt("10.3456") // returns 10
+"10.3456" // returns 10.3456
```

Though an old question, but maybe this can be helpful to someone.

I use this way of converting string to ~~int~~ number

```
var str = "25"; // string
var number = str*1; // number
```

So, when multiplying by 1, the value does not change, but js automatically returns a number.

But as it is shown below, this should be used if you are sure that the `str`

is a number(or can be represented as a number), otherwise it will return NaN - not a number.

you can create simple function to use, e.g.

```
function toNumber(str) {
return str*1;
}
```

```
var x = "1000"*1;
```

Here is little comparison of speed (Mac Os only)... :)

For chrome 'plus' and 'mul' are fastest (>700,000,00 op/sec), 'Math.floor' is slowest. For Firefox 'plus' is slowest (!) 'mul' is fastest (>900,000,000 op/sec). In Safari 'parseInt' is fastes, 'number' is slowest (but resulats are quite similar, >13,000,000 <31,000,000). So Safari for cast string to int is more than 10x slower than other browsers. So the winner is '**mul**' :)

You can run it on your browser by this link https://jsperf.com/js-cast-str-to-number/1

**Update**

I also test `var x = ~~"1000";`

- on Chrome and Safari is a little bit slower than `var x = "1000"*1`

(<1%), on Firefox is a little bit faster (<1%). I update above picture and test

Try parseInt.

```
var number = parseInt("10", 10); //number will have value of 10.
```

I posted the wrong answer here, sorry. fixed.

This is an old question, but I love this trick:

```
~~"2.123"; //2
~~"5"; //5
```

The double bitwise negative drops off anything after the decimal point AND converts it to a number format. I've been told it's slightly faster than calling functions and whatnot, but I'm not entirely convinced.

EDIT: Another method I just saw here (a question about the javascript >>> operator, which is a zero-fill right shift) which shows that shifting a number by 0 with this operator converts the number to a **uint32** which is nice if you also want it **unsigned**. Again, this converts to an **unsigned integer**, which can lead to strange behaviors if you use a signed number.

```
"-2.123" >>> 0; // 4294967294
"2.123" >>> 0; // 2
"-5" >>> 0; // 4294967291
"5" >>> 0; // 5
```

Beware if you use parseInt to convert a float in scientific notation! For example:

```
parseInt("5.6e-14")
```

will result in

```
5
```

instead of

```
0
```

To convert a String into Integer, I recommend using parseFloat and **NOT** parseInt. Here's why:

**Using parseFloat:**

```
parseFloat('2.34cms') //Output: 2.34
parseFloat('12.5') //Output: 12.5
parseFloat('012.3') //Output: 12.3
```

**Using parseInt:**

```
parseInt('2.34cms') //Output: 2
parseInt('12.5') //Output: 12
parseInt('012.3') //Output: 12
```

So if you have noticed parseInt discards the values after the decimals, whereas parseFloat lets you work with floating point numbers and hence more suitable if you want to retain the values after decimals. Use parseInt if and only if you are sure that you want the integer value.

Also as a side note: Mootools has the function toInt() which is used on any native string (or float (or integer)).

```
"2".toInt() // 2
"2px".toInt() // 2
2.toInt() // 2
```

Please see the below example.It will help clear your doubt

```
Example Result
parseInt("4") 4
parseInt("5aaa") 5
parseInt("4.33333") 4
parseInt("aaa"); NaN (means "Not a Number")
```

by using parseint function It will only give op of integer present and not the string

we can use `+(stringOfNumber)`

instead of using `parseInt(stringOfNumber)`

Ex: `+("21")`

returns int of 21 like the `parseInt("21")`

.

we can use this unary "+" operator for parsing float too...

Try `str - 0`

to convert `string`

to `number`

.

```
> str = '0'
> str - 0
0
> str = '123'
> str - 0
123
> str = '-12'
> str - 0
-12
> str = 'asdf'
> str - 0
NaN
> str = '12.34'
> str - 0
12.34
```

Here are two links to compare the performance of several ways to convert string to int

There are many ways in JavaScript to convert a string to a number value... All simple and handy, choose the way which one works for you:

```
var num = Number("999.5"); //999.5
var num = parseInt("999.5", 10); //999
var num = parseFloat("999.5"); //999.5
var num = +"999.5"; //999.5
```

Also any **Math** operation converts them to number, for example...

```
var num = "999.5" / 1; //999.5
var num = "999.5" * 1; //999.5
var num = "999.5" - 1 + 1; //999.5
var num = "999.5" - 0; //999.5
var num = Math.floor("999.5"); //999
var num = ~~"999.5"; //999
```

My prefer way is using `+`

sign, which is the elegant way to convert a string to number in JavaScript.

Google gave me this answer as result, so...

I actually needed to "save" a string as an integer, for a binding between C and JavaScript, so I convert the string into a integer value:

```
/*
Examples:
int2str( str2int("test") ) == "test" // true
int2str( str2int("t€st") ) // "t¬st", because "€".charCodeAt(0) is 8364, will be AND'ed with 0xff
Limitations:
max 4 chars, so it fits into an integer
*/
function str2int(the_str) {
var ret = 0;
var len = the_str.length;
if (len >= 1) ret += (the_str.charCodeAt(0) & 0xff) << 0;
if (len >= 2) ret += (the_str.charCodeAt(1) & 0xff) << 8;
if (len >= 3) ret += (the_str.charCodeAt(2) & 0xff) << 16;
if (len >= 4) ret += (the_str.charCodeAt(3) & 0xff) << 24;
return ret;
}
function int2str(the_int) {
var tmp = [
(the_int & 0x000000ff) >> 0,
(the_int & 0x0000ff00) >> 8,
(the_int & 0x00ff0000) >> 16,
(the_int & 0xff000000) >> 24
];
var ret = "";
for (var i=0; i<4; i++) {
if (tmp[i] == 0)
break;
ret += String.fromCharCode(tmp[i]);
}
return ret;
}
```

In my opinion, no answer covers all edge cases as parsing a float should result in an error.

```
function parseInteger(value) {
if(value === '') return NaN;
const number = Number(value);
return Number.isInteger(number) ? number : NaN;
}
```

```
parseInteger("4") // 4
parseInteger("5aaa") // NaN
parseInteger("4.33333") // NaN
parseInteger("aaa"); // NaN
```

**Here is the easiest solution**

```
let myNumber = "123" | 0;
```

**More easy solution**

```
let myNumber = +"123";
```

all of the above are correct. Please be sure before that this is a number in a string by doing "typeot x === 'number'" other wise it will return NaN

```
var num = "fsdfsdf242342";
typeof num => 'string';
var num1 = "12423";
typeof num1 => 'number';
+num1 = > 12423`
```

Another option is to double XOR the value with itself:

```
var i = 12.34;
console.log('i = ' + i);
console.log('i ? i ? i = ' + (i ^ i ^ i));
```

This will output:

```
i = 12.34
i ? i ? i = 12
```

**I only added one plus(+) before string and that was solution!**

```
+"052254" //52254
```

Hope it helps ;)

Summing the multiplication of digits with their respective power of ten:

i.e: 123 = 100+20+3 = 1*100 + 2+10 + 3*1 = 1*(10^2) + 2*(10^1) + 3*(10^0)

```
function atoi(array) {
// use exp as (length - i), other option would be to reverse the array.
// multiply a[i] * 10^(exp) and sum
let sum = 0;
for (let i = 0; i < array.length; i++) {
let exp = array.length-(i+1);
let value = array[i] * Math.pow(10,exp);
sum+=value;
}
return sum;
```

}

```
function doSth(){
var a = document.getElementById('input').value;
document.getElementById('number').innerHTML = toNumber(a) + 1;
}
function toNumber(str){
return +str;
}
```

```
<input id="input" type="text">
<input onclick="doSth()" type="submit">
<span id="number"></span>
```

I use this

```
String.prototype.toInt = function (returnval) {
var i = parseInt(this);
return isNaN(i) ? returnval !== undefined ? returnval : - 1 : i;
}
```

this way I always get an int back.

The safest way to ensure you get a valid integer:

```
let integer = (parseInt(value, 10) || 0);
```

Examples:

```
// Example 1 - Invalid value:
let value = null;
let integer = (parseInt(value, 10) || 0);
// => integer = 0
```

```
// Example 2 - Valid value:
let value = "1230.42";
let integer = (parseInt(value, 10) || 0);
// => integer = 1230
```

```
// Example 3 - Invalid value:
let value = () => { return 412 };
let integer = (parseInt(value, 10) || 0);
// => integer = 0
```

```
function parseIntSmarter(str) {
// ParseInt is bad because it returns 22 for "22thisendsintext"
// Number() is returns NaN if it ends in non-numbers, but it returns 0 for empty or whitespace strings.
return isNaN(Number(str)) ? NaN : parseInt(str, 10);
}
```

you can use plus, for example=>

var personAge = '24'; var personAge1 = (+personAge)

then you can see typeof personAge is number

©2020 All rights reserved.