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

时间：2009-07-15 20:22:48

标签： javascript string integer data-conversion parseint

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

29 个答案:

答案 0 :(得分：1945)

最简单的方法是使用原生Number函数：

var x = Number("1000")

如果这对您不起作用，那么 parseInt ，一元加， parseFloat与楼层和 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并根据需要对其进行舍入。我在这里用地板。

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)

答案 1 :(得分：206)

尝试使用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

答案 2 :(得分：118)

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

<强>解析 

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

parseInt和parseFloat是用于将字符串解析为数字的两个函数。如果它解决了一个它无法识别的字符，那么解析就会默默地停止，这对解析像＃24; 92px＆＃34;这样的字符串很有用，但它也有点危险，因为它赢了“＃”。 t给你输入错误的任何错误，而不是你回来NaN，除非字符串以数字开头。字符串开头的空格将被忽略。这是一个例子，表明它做了与你想要的不同的事情，并没有表明出现任何问题：

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

总是将基数指定为第二个参数是一种好习惯。在较旧的浏览器中，如果字符串以0开头，如果未指定基数则会将其解释为八进制，这会让很多人感到意外。如果没有指定基数，则通过使字符串以0x开头来触发十六进制的行为，例如， 0xff。标准实际上是用ecmascript 5改变的，所以如果没有指定基数，那么现代浏览器不再触发八进制。 parseInt可以理解基数为36的基数，在这种情况下，大写和小写字母都被视为等价。

将字符串的类型更改为数字

上面提到的所有其他不使用parseInt的技巧都涉及隐含地将字符串强制转换为数字。我更愿意明确地这样做，

var cast = Number("97");

这与解析方法有不同的行为（尽管它仍然忽略空格）。它更严格：如果它不理解整个字符串而不是它返回NaN，那么你就不能将它用于像97px这样的字符串。由于您需要原始数字而不是数字包装器对象，因此请确保不要将new放在数字函数前面。

显然，转换为Number会给出一个可能是float而不是整数的值，所以如果你想要一个整数，你需要修改它。有几种方法可以做到这一点：

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

请记住，所有这些方法都理解指数表示法，因此2e2是200而不是NaN。此外，Number理解＆＃34; Infinity＆＃34;，而解析方法不是。

自定义

这些方法中的任何一种都不可能完全符合您的要求。例如，如果解析失败，我通常会想要抛出一个错误，而且我不需要支持Infinity，指数或前导空格。根据您的用例，有时编写自定义转换函数是有意义的。

始终检查Number或其中一个解析方法的输出是否是您期望的数字。您几乎肯定希望使用isNaN来确保该数字不是NaN（通常是您发现解析失败的唯一方法）。

答案 3 :(得分：50)

ParseInt（）和+是不同的

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

答案 4 :(得分：36)

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

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

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

因此，当乘以1时，该值不会改变，但js会自动返回一个数字。

但如下图所示，如果你确定str是一个数字（或者可以表示为数字），则应该使用它，否则它将返回NaN而不是数字。

您可以创建简单的功能，例如

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

enter image description here

答案 5 :(得分：32)

尝试parseInt。

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

答案 6 :(得分：27)

最快

var x = "1000"*1;

测试

这里几乎没有速度比较（仅限Mac Os）...... :)

对于chrome＆＃39; plus＆＃39;和＆＃39; mul＆＃39;最快（> 700,000,00 op / sec），＆＃39; Math.floor＆＃39;是最慢的。对于Firefox＆＃39; plus＆＃39;是最慢的（！）＆＃39; mul＆＃39;最快（> 900,000,000 op / sec）。在Safari＆＃t; parseInt＆＃39;很有吸引力，＆＃39;数字＆＃39;是最慢的（但是，恢复非常相似，> 13,000,000 <31,000,000）。因此，用于将字符串转换为int的Safari比其他浏览器慢10倍。所以获胜者是 mul ＆＃39; ：）

您可以通过此链接在浏览器上运行它 https://jsperf.com/casttonumber

enter image description here

<强>更新

我也测试var x = ~~"1000"; - 在Chrome和Safari上比var x = "1000"*1（<1％）慢一点，在Firefox上稍微快一点（<1％）。

答案 7 :(得分：26)

我在这里发错了答案，抱歉。固定的。

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

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

双位按位负数会在小数点后删除任何内容并将其转换为数字格式。我被告知它比调用函数和诸如此类的东西稍快，但我并不完全相信。

编辑：我刚看到的另一种方法here（关于javascript＆gt;＆gt;＆gt;运算符的问题，这是一个零填充右移），它显示了使用此运算符将数字移位0 uint32 的数字，如果您还想要无符号，那就太好了。同样，这将转换为无符号整数，如果您使用带符号的数字，可能会导致奇怪的行为。

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

答案 8 :(得分：18)

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

parseInt("5.6e-14")

将导致

5

而不是

0

答案 9 :(得分：15)

另外作为旁注：Mootools的函数toInt（）用于任何本地字符串（或浮点数（或整数））。

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

答案 10 :(得分：14)

要将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。

答案 11 :(得分：14)

请参阅以下示例。这将有助于消除您的疑问

Example                  Result

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

使用parseint函数它只给出整数存在的op而不是字符串

答案 12 :(得分：12)

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

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

我们可以使用这个一元“+”运算符来解析float ...

答案 13 :(得分：10)

尝试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

答案 14 :(得分：9)

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中将字符串转换为数字的优雅方式。

答案 15 :(得分：7)

谷歌给了我这个答案，所以......

我实际上需要＆＃34;保存＆＃34;字符串作为整数，用于C和JavaScript之间的绑定，因此我将字符串转换为整数值：

class Person:

    def __init__(self, name):
        self.name = name # Setting the name of the 'person'

    def wave(self): # The methods which is called with George.wave()
        print(self.name + ' waves at you.')
George = Person('George')
George.wave()

答案 16 :(得分：6)

在我看来，没有答案涵盖所有边缘情况，因为解析float会导致错误。

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

答案 17 :(得分：2)

在 Javascript 中，您可以执行以下操作：-

ParseInt

parseInt("10.5") //returns 10

乘以 1

var s = "10";
s = s*1;  //returns 10

使用一元运算符 (+)

var s = "10";
s = +s;  //returns 10

使用按位运算符

（注意：它在2140000000之后开始中断。例如：- ~~"2150000000" = -2144967296）

var s= "10.5";
s = ~~s; //returns 10

使用 Math.floor() 或 Math.ceil()

var s = "10";
s = Math.floor(s) || Math.ceil(s); //returns 10

答案 18 :(得分：1)

以上所有都是正确的。在此之前请确保这是一个字符串中的数字，通过“typeot x ==='number'”，否则它将返回NaN 

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

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

答案 19 :(得分：1)

另一种选择是将值与自身重复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 :(得分：1)

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

答案 21 :(得分：0)

＆＃13;
＆＃13; 
function doSth(){
  var a = document.getElementById('input').value;
  document.getElementById('number').innerHTML = toNumber(a) + 1;
}
function toNumber(str){
  return +str;
}
＆＃13; 
<input id="input" type="text">
<input onclick="doSth()" type="submit">
<span id="number"></span>
＆＃13;
＆＃13;
＆＃13;

答案 22 :(得分：0)

我用这个

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

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

答案 23 :(得分：0)

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

+"052254" //52254

希望它会有所帮助;）

答案 24 :(得分：0)

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

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

}

答案 25 :(得分：0)

这是最简单的解决方案 

let myNumber = "123" | 0;

答案 26 :(得分：0)

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

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 :(得分：0)

您可以使用加号，例如=>

var personAge ='24'; var personAge1 =（+ personAge）

然后您会看到personofge的类型是数字

答案 28 :(得分：0)

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

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

相关问题
最新问题