试试parseInt。

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

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

最简单的方法是使用原生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");

parseFloat（）方法名称

如果你是那种在调用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具有toInt（）函数，该函数用于任何本机字符串（或浮点数（或整数））。

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

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

parseInt("5.6e-14")

将导致

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放在Number函数前面。

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

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

任何按位运算符（这里我已经做了按位或，但你也可以做双重否定，就像在前面的答案或位移位中一样）将值转换为32位整数，其中大多数将转换为有符号整数。请注意，这个不会做你想要的大整数。如果整数不能用32位表示，它将包装。

~~"3000000000.654" === -1294967296// This is the same asNumber("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 asMath.floor(Number("3000000000.654"))

请记住，强制理解指数表示法和Infinity，因此2e2是200而不是NaN，而解析方法则不是。

自定义

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

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

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

var str = "25";       // Stringvar number = str*1;   // Number

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

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

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

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

要将字符串转换为整数，我建议使用parseFloat和<强>不 parseInt。原因如下：

使用parseFloat：

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

使用parseInt：

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

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

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

示例：+("21")返回21的整数，就像parseInt("21")一样。

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

尝试str - 0将string转换为number。

> str = '0'> str - 00> str = '123'> str - 0123> str = '-12'> str - 0-12> str = 'asdf'> str - 0NaN> str = '12.34'> str - 012.34

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

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

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

请看下面的例子，它将有助于回答你的问题。

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

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

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

/*Examples:int2str( str2int("test") ) == "test" // trueint2str( str2int("t€st") ) // "t¬st", because "€".charCodeAt(0) is 8364, will be AND'ed with 0xffLimitations:maximum 4 characters, 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;}

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

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

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

最快

var x = "1000"*1;

测试

这里有一些速度比较（仅限macOS）…：）

Chrome，'plus'和'mul'最快（>700,000,00 op/sec），'Math.floor'最慢。对于Firefox，'plus'最慢（！）'mul'最快（>900,000,000 op/sec）。在Safari'parseInt'最快，'num'最慢（但结果非常相似，>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%）。

前面的所有答案都是正确的。请先通过执行“typeot x==='num'”来确定这是字符串中的数字。否则，它将返回NaN。

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

JavaScript中有很多方法可以将字符串转换为数字值……所有这些都很简单方便。选择适合您的方式：

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

此外，任何Math操作都会将它们转换为数字，例如…

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

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

另一种选择是将值与自身XOR翻倍：

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

这将输出：

i = 12.34i ⊕ i ⊕ i = 12

我用这个

String.prototype.toInt = function (returnval) {var i = parseInt(this);return isNaN(i) ? returnval !== undefined ? returnval : - 1  :      i;}
var str = "7";var num = str.toInt(); // outputs 7, if not str outputs -1//orvar num = str.toInt(0); // outputs 7, if not str outputs 0

这样我总是得到一个int。

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

+"052254" // 52254

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

即：123=100+20+3=1100+2+10+31=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;}

这是最简单的解决办法

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

您可以使用plus。例如：

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

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

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

"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]) * factorfactor *= 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 NaNresult += parseInt(str[i - 1]) * factorfactor *= 10}
return result}
console.log(extractInteger(str))

在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

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

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

数量（）

Number(" 200.12 ")  // Returns 200.12
Number("200.12")  // Returns 200.12
Number("200") // Returns 200

parseInt（）

parseInt(" 200.12 ")  // Return 200
parseInt("200.12")  // Return 200
parseInt("200") // Return 200
parseInt("Text information") // Returns NaN

parseFloat（）方法名称

它将返回第一个数字

parseFloat("200 400")  // Returns 200
parseFloat("200") // Returns 200
parseFloat("Text information") // Returns NaN
parseFloat("200.10")  // Return 200.10

Math.floor（）

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

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

JavaScript中的字符串到数字：

一元+（最推荐）

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

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

一些其他选项：

解析字符串：

• parseInt(numStr)表示整数
• parseFloat(numStr)表示整数和小数

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

JavaScript函数

• 数学函数，如round(numStr), floor(numStr), ceil(numStr)表示整数

• Number(numStr)表示整数和小数

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

一元运算符

• 所有基本的一元操作符，+numStr、numStr-0、1*numStr、numStr*1和numStr/1

• 全部支持整数和小数

• 小心numStr+0。它返回一个字符串。

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

位运算符

• 两个波浪号~~numStr或左移0，numStr<<0
• 仅支持整数，不支持小数

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

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