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

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

试试parseInt

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

尝试parseInt函数：

var number = parseInt("10");

var x = Number("1000")

但有一个问题。如果您尝试使用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

---

最简单的方法是使用本机

Number

函数：

var number = parseInt("10");

var x = Number("1000")

如果这对您不起作用，那么有parseInt、一元加号、parseFloat with 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

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

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)

---

另请注意：Mootools具有用于任何本机字符串（或float（或integer））的函数toInt（）

---

如果使用parseInt转换科学记数法中的浮点，请小心！ 例如：

parseInt("5.6e-14") 

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

将导致

5 

而不是

0

ParseInt（）和+是不同的

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

---

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

这是个老问题，但我喜欢这个把戏：

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

双位负数去掉小数点后的任何内容，并将其转换为数字格式。有人告诉我，它比调用函数之类的稍快一点，但我并不完全相信

编辑：我刚才看到的另一种方法（关于javascript>>>操作符的问题，它是一个零填充右移），它显示用这个操作符将一个数字移动0，将该数字转换为一个uint32，如果您还想要它无符号的话，这很好。同样，这会转换为无符号整数，如果使用有符号的数字，可能会导致奇怪的行为

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

---

在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

之类的字符串。因为您想要的是一个基本数字而不是数字包装对象，所以请确保不要将

new

放在数字函数前面

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

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

任何按位运算符（这里我做了按位or运算，但也可以像前面的答案或按位移位一样进行双反运算）都会将值转换为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"))

请记住，coeercion理解指数表示法和无穷大，因此

2e2

是

200

而不是NaN，而解析方法则不是

定制

这两种方法都不可能完全满足您的需求。例如，通常我希望在解析失败时抛出一个错误，并且我不需要支持无穷大、指数或前导空格。根据您的用例，有时编写自定义转换函数是有意义的

始终检查Number或其中一个解析方法的输出是否为您期望的数字。您几乎肯定要使用

isNaN

来确保数字不是NaN（通常是发现解析失败的唯一方法）。

> 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

Example                  Result

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

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

var x = "1000"*1;

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

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

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

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

+"052254" //52254

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;

let myNumber = "123" | 0;

let myNumber = +"123";

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

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

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

parseInt("10.5") //returns 10

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

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

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

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