如何将字符串转换为JavaScript中的integer

Question

如何将字符串转换为 JavaScript 中的 integer？

Answer 1

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

var x = Number("1000")

如果这对您不起作用，那么还有parseInt 、 unary plus 、带有 floor 的 parseFloat和Math.round方法。

解析：

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)

Answer 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在解析任何有效内容后会忽略错误数据。
该指南将解析为 51：

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

Answer 3

在 javascript 中，有两种主要的方法可以将字符串转换为数字。 一种方法是解析它，另一种方法是将其类型更改为数字。 其他答案中的所有技巧（例如一元加号）都涉及将字符串的类型隐式强制为数字。 您也可以使用 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 函数前面。

显然，转换为数字会为您提供一个可能是浮点数而不是整数的值，因此如果您想要一个整数，则需要对其进行修改。 有几种方法可以做到这一点：

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，而解析方法则不然。

风俗

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

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

Answer 4

ParseInt() 和 + 是不同的

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

Answer 5

最快的

var x = "1000"*1;

测试

这是速度的小比较（仅限Mac Os）...... :)

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

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

更新

我还测试var x = ~~"1000"; - 在 Chrome 和 Safari 上比var x = "1000"*1 (<1%) 慢一点，在 Firefox 上快一点 (<1%)。 我更新上面的图片并测试

Answer 6

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

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

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

所以，乘以1的时候，值没有变化，但是js会自动返回一个数字。

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

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

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

Answer 7

试试 parseInt。

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

Answer 8

我在这里发布了错误的答案，对不起。 固定的。

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

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

双位负数删除小数点后的任何内容并将其转换为数字格式。 有人告诉我它比调用函数和诸如此类的东西要快一些，但我并不完全相信。

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

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

Answer 9

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

parseInt("5.6e-14") 

将导致

5 

代替

0

Answer 10

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

解析整数

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

Answer 11

请看下面的例子。它将帮助您消除疑问

Example                  Result

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

通过使用 parseint 函数它只会给出整数的 op 而不是字符串

Answer 12

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

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

Answer 13

要将字符串转换为整数，我建议使用 parseFloat 而不是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。

Answer 14

我们可以使用+(stringOfNumber)而不是使用parseInt(stringOfNumber)

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

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

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

Answer 16

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

这里有两个链接来比较几种将string转换为int的方法的性能

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

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

Answer 17

这是最简单的解决方案

let myNumber = "123" | 0;

更简单的解决方案

let myNumber = +"123";

Answer 18

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

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

Answer 19

最简单的方法是像这样使用+

const strTen = "10"
const numTen = +strTen      // string to number conversion
console.log(typeof strTen)  // string
console.log(typeof numTen)  // number

Answer 20

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

我实际上需要将字符串“保存”为整数，用于 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;
}

Answer 21

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

Answer 22

您可以使用加号。 例如：

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

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

Answer 23

另一种选择是将值与自身进行双 XOR：

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

这将输出：

i = 12.34
i ⊕ i ⊕ i = 12

Answer 24

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

+"052254" //52254

希望能帮助到你 ;）

Answer 25

将数字的乘法与它们各自的 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;

}

Answer 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

Answer 27

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

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

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

Answer 28

 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>

Answer 29

我用这个

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

这样我总是得到一个 int 回来。

Answer 30

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

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

Answer 31

JavaScript 中的字符串到数字：

一元+（最推荐）

• +numStr易于使用，与其他产品相比性能更好
• 支持整数和小数

console.log(+'123.45') //=> 123.45

其他一些选项：

解析字符串：

• parseInt(numStr)用于整数
• parseFloat(numStr)用于整数和小数

console.log(parseInt('123.456')) //=> 123
console.log(parseFloat('123')) //=> 123

JavaScript 函数

• 整数的数学函数，如round(numStr),floor(numStr),ceil(numStr)
• 整数和小数的Number(numStr)

console.log(Math.floor('123')) //=> 123
console.log(Math.round('123.456')) //=> 123
console.log(Math.ceil('123.454')) //=> 124
console.log(Number('123.123')) //=> 123.123

一元运算符

• 所有基本一元运算符+numStr , numStr-0 , 1*numStr , numStr*1 , numStr/1
• 全部支持整数和小数
• 注意numStr+0 ，它返回字符串

console.log(+'123') //=> 123
console.log('002'-0)//=> 2
console.log(1*'5') //=> 5
console.log('7.7'*1) //=> 7.7
console.log(3.3/1) //=>3.3
console.log('123.123'+0, typeof ('123.123'+0)) //=> 123.1230 string

位运算符

• 2 波浪号~~numStr或左移 0 numStr<<0
• 只支持整数，不支持小数

console.log(~~'123') //=> 123
console.log('0123'<<0) //=> 123
console.log(~~'123.123') //=> 123
console.log('123.123'<<0) //=> 123

 // parsing console.log(parseInt('123.456')) //=> 123 console.log(parseFloat('123')) //=> 123 // function console.log(Math.floor('123')) //=> 123 console.log(Math.round('123.456')) //=> 123 console.log(Math.ceil('123.454')) //=> 124 console.log(Number('123.123')) //=> 123.123 // unary console.log(+'123') //=> 123 console.log('002'-0)//=> 2 console.log(1*'5') //=> 5 console.log('7.7'*1) //=> 7.7 console.log(3.3/1) //=>3.3 console.log('123.123'+0, typeof ('123.123'+0)) //=> 123.1230 string //bitwise console.log(~~'123') //=> 123 console.log('0123'<<0) //=> 123 console.log(~~'123.123') //=> 123 console.log('123.123'<<0) //=> 123

Answer 32

Number(" 200.12 ") // return 200.12

Number("200.12") // return 200.12

Number("200") // return 200

parseInt(" 200.12 ") // return 200

parseInt("200.12") // return 200

parseInt("200") // return 200

parseInt("文本信息") // return NaN

---

它将返回第一个数字

---

parseFloat("200 400") // return 200

parseFloat("200") // return 200

parseFloat("文本信息") // return NaN

parseFloat("200.10") // return 200.10

---

将数字四舍五入到最接近的整数

---

Math.floor(" 200.12 ") // return 200

Math.floor("200.12") // return 200

Math.floor("200") // return 200

Answer 33

尝试这个

let x = '5'; 
let y = +x; 
console.log(y); 
Output = 5