如何在JavaScript中将字符串转换为整数？

#1 楼

最简单的方法是使用本机Number函数：

var x = Number("1000")

如果这对您不起作用，则存在parseInt，一元加，parseFloat和floor和Math.round方法。

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])

一元加号
，如果您的字符串已经是形式为整数：

var x = +"1000";

如果您的字符串是浮点数或可能是浮点数，并且您想要一个整数：

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

或者，如果您要多次使用Math.floor：

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

如果您是那种在通话时忘记将基数放入的类型parseInt，您可以使用parseFloat并根据需要舍入。在这里，我使用floor。

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

有趣的是，Math.round（如Math.floor）将进行字符串到数字的转换，因此如果要对数字进行四舍五入（或如果字符串中有整数），这是一种很好的方法，也许是我最喜欢的方法：

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

#2 楼

尝试parseInt函数：

var number = parseInt("10");

但是有问题。如果尝试使用parseInt函数转换“ 010”，它将检测为八进制数字，并返回数字8。因此，您需要指定一个基数（从2到36）。在这种情况下，以10为基础。

parseInt(string, radix)

示例：

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

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

请注意，parseInt解析后会忽略错误数据任何有效的内容。
此GUID将解析为51：

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

#3 楼

在javascript中，有两种将字符串转换为数字的主要方法。一种方法是解析它，另一种方法是将其类型更改为Number。其他答案（例如一元加号）中的所有技巧都涉及将字符串的类型隐式强制为数字。您还可以使用Number函数显式地执行相同的操作。
解析

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

parseInt和parseFloat是用于将字符串解析为数字的两个函数。如果解析遇到无法识别的字符，解析将默默地停止，这对于解析“ 92px”之类的字符串很有用，但它也有些危险，因为在输入错误时不会给您带来任何错误，而是除非字符串以数字开头，否则将返回NaN。字符串开头的空格将被忽略。这是一个示例，它执行与您想要的操作不同的操作，并且不表示出现任何错误：

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

始终将基数指定为第二个参数是一个好习惯。在较旧的浏览器中，如果字符串以0开头，那么如果未指定基数，它将被解释为八进制，这使很多人感到惊讶。如果未指定基数，则字符串以0x开头来触发十六进制行为。 0xff。标准实际上是随ecmascript 5更改的，因此，如果未指定基数，则现代浏览器在前导0时不再触发八进制。 parseInt可以理解基数不超过36的基数，在这种情况下，大写和小写字母都被视为等效。
将字符串的类型更改为数字
上面提到的所有其他技巧使用parseInt，涉及将字符串隐式强制为数字。我更喜欢明确地执行此操作，

var cast = Number("97");

这与解析方法有不同的行为（尽管它仍然忽略空格）。更为严格：如果它不能理解整个字符串，则返回的是NaN，因此您不能将其用于类似97px的字符串。由于您要使用原始数字而不是Number包装器对象，因此请确保不要将new放在Number函数的前面。
显然，转换为Number可能会产生一个浮点数而不是一个浮点数整数，因此如果需要整数，则需要对其进行修改。有几种方法可以执行此操作：

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

任何按位运算符（在这里，我已经按位进行了运算，但是您也可以进行双重求反，因为在较早的答案或位移中是）。值转换为32位整数，并且大多数将转换为带符号整数。请注意，这对于大整数是不希望的。如果整数不能以32位表示，则将自动换行。

~~"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

要正确处理较大的数字，应使用四舍五入方法

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

请记住，coerrcion理解指数表示法和无穷大，因此2e2是200而不是NaN，而解析方法却不是。
自定义
这两种方法都不大可能完全满足您的要求。例如，通常我希望解析失败时抛出错误，并且不需要Infinity，指数或前导空格。根据您的用例，有时编写一个自定义转换函数很有意义。
始终检查Number的输出或其中一种解析方法是否符合您的期望。您几乎肯定会想要使用isNaN来确保数字不是NaN（通常是您发现解析失败的唯一方法）。

#4 楼

ParseInt（）和+不同

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

#5 楼

最快

var x = "1000"*1;

测试

这里的速度比较很少（仅Mac OS）... :)

对于chrome，“ plus”和“ mul”最快（> 700,000,00 op / sec），“ Math.floor”最慢。对于Firefox，“加号”最慢（！），“ mul”最快（> 900,000,000 op / sec）。在Safari中，“ parseInt”是禁食，“ number”是最慢的（但结果非常相似，> 13,000,000 <31,000,000）。因此，Safari将字符串转换为int的速度比其他浏览器慢10倍以上。所以赢家是'mul':)

您可以通过此链接在浏览器上运行它
https://jsperf.com/js-cast-str-to-number/1



更新

我也测试了var x = ~~"1000";-在Chrome和Safari上比var x = "1000"*1（<1％）慢一些，在Firefox上快一点（<1％）。我更新了上面的图片并进行了测试

#6 楼

虽然这是一个老问题，但也许对某人有所帮助。

我使用这种将字符串转换为int数的方法

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

，当乘以1时，值不变，但是js自动返回一个数字。但是，如下所示，如果您确定str是一个数字（或可以表示为数字），否则将返回NaN-而不是数字。

您可以创建要使用的简单函数，例如

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

#7 楼

尝试parseInt。

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

#8 楼

我在这里张贴了错误的答案，对不起。已修复。

这是一个老问题，但我喜欢这个技巧：

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

双位负数会在小数点后下降AND将其转换为数字格式。有人告诉我它比调用函数和诸如此类的要快一些，但是我并不完全相信。

编辑：我刚刚在这里看到的另一种方法（关于javascript >>>运算符的问题，是一个零填充的右移），这表明使用此运算符将数字移位0会将数字转换为uint32，如果您也希望它不带符号，则很好。同样，这将转换为无符号整数，如果您使用有符号数字，则可能导致奇怪的行为。

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

#9 楼

请注意，如果您使用parseInt转换科学计数形式的浮点数！
例如：

parseInt("5.6e-14") 

将导致

5 

代替

0

#10 楼

另请注意：Mootools具有toInt（）函数，该函数可用于任何本机字符串（或浮点数（或整数））。

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

#11 楼

要将String转换为Integer，我建议使用parseFloat和NOT parseInt。原因如下：

使用parseFloat：

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

使用parseInt：

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

因此，如果您注意到parseInt会舍弃小数点后的值，而parseFloat则允许您使用浮点数，因此如果要保留小数点后的值，则更适合。仅当您确定要使用整数值时，才使用parseInt。

#12 楼

请参阅下面的示例。它将使用parseint函数帮助您消除疑虑。

Example                  Result

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

通过使用parseint函数，它将仅给出存在整数的op，而不给出字符串

#13 楼

我们可以使用+(stringOfNumber)代替parseInt(stringOfNumber)

例如：+("21")像parseInt("21")一样返回21的int。

我们也可以使用此一元“ +”运算符来解析float。 。

#14 楼

尝试使用str - 0将string转换为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

这里有两个链接，用于比较几种将字符串转换为int的方法的性能

https ：//jsperf.com/number-vs-parseint-vs-plus

http://phrogz.net/js/string_to_number.html

#15 楼

JavaScript中有多种方法可以将字符串转换为数字值...简便易行，请选择一种适合您的方式：

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

也可以数学运算将它们转换为数字，例如...

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

我更喜欢的方法是使用+符号，这是在JavaScript中将字符串转换为数字的一种优雅方法。

#16 楼

Google给出了这个答案，所以...

我实际上需要将字符串“保存”为整数，以便在C和JavaScript之间进行绑定，因此我将字符串转换为整数值：

/*
    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;
}

#17 楼

在我看来，没有任何答案能解决所有极端情况，因为解析浮点数会导致错误。

 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
 

#18 楼

这是最简单的解决方案

let myNumber = "123" | 0;

更简单的解决方案

let myNumber = +"123";

#19 楼

另一个选择是将值与自身进行XOR运算：

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

这将输出：

 i = 12.34
i ⊕ i ⊕ i = 12
 

#20 楼

我只在字符串前加了一个加号（+），这才是解决方案！

+"052254" //52254

希望有帮助;）

#21 楼

将数字的乘积与它们各自的10的幂相加：

即：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;

}

#22 楼

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);
}

#23 楼

以上所有内容均正确。请先通过执行“ typeot x ==='number'”来确保这是字符串中的数字，否则将返回NaN

 var num = "fsdfsdf242342";
 typeof num => 'string';

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

#24 楼

 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> 

#25 楼

我用这个

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

这样我总是能得到一个整数。

#26 楼

确保获得有效整数的最安全方法：

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

示例：

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

#27 楼

您可以使用加号。
例如：

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

，然后您可以通过typeof personAge1看到新变量的类型；这是number。

#28 楼

这（可能）不是解析整数的最佳解决方案，但如果您需要“提取”一个整数，例如：

 "1a2b3c" === 123
"198some text2hello world!30" === 198230
// ...
 

这将起作用（仅适用于整数）：

 var str = '3a9b0c3d2e9f8g'

function extractInteger(str) {
  var result = 0;
  var factor = 1

  for (var i = str.length; i > 0; i--) {
    if (!isNaN(str[i - 1])) {
      result += parseInt(str[i - 1]) * factor
      factor *= 10
    }
  }

  return result
}

console.log(extractInteger(str)) 

当然，这也可以解析整数，但是比其他方法要慢。
也可以使用此方法解析整数，如果字符串不是整数，则返回NaN数字，但我不明白您为什么要这么做，因为它内部依赖parseInt，而parseInt可能更快。

 var str = '3a9b0c3d2e9f8g'

function extractInteger(str) {
  var result = 0;
  var factor = 1

  for (var i = str.length; i > 0; i--) {
    if (isNaN(str[i - 1])) return NaN
    result += parseInt(str[i - 1]) * factor
    factor *= 10
  }

  return result
}

console.log(extractInteger(str))