这条线有哪些区别：
var a = parseInt("1", 10); // a === 1
和这一行
var a = +"1"; // a === 1
这个jsperf测试显示在当前版本的Chrome中，一元运算符比parseInt更快，假设它是为node.js而设计的！？
如果我尝试转换不是数字的字符串，两者都会返回NaN：
var b = parseInt("test", 10); // b === NaN
var b = +"test"; // b === NaN
那么，在什么情况下我应该优先使用parseInt而不是一元加法（特别是在node.js中）？
编辑：与双波浪线运算符~~有什么区别？
终极的任何转数字表格：
EXPRS = [
'parseInt(x)',
'parseFloat(x)',
'Number(x)',
'+x',
'~~x',
'x>>>0',
'isNaN(x)'
];
VALUES = [
'"123"',
'"+123"',
'"-123"',
'"123.45"',
'"-123.45"',
'"12e5"',
'"12e-5"',
'"0123"',
'"0000123"',
'"0b111"',
'"0o10"',
'"0xBABE"',
'"4294967295"',
'"123456789012345678"',
'"12e999"',
'""',
'"123foo"',
'"123.45foo"',
'" 123 "',
'"foo"',
'"12e"',
'"0b567"',
'"0o999"',
'"0xFUZZ"',
'"+0"',
'"-0"',
'"Infinity"',
'"+Infinity"',
'"-Infinity"',
'BigInt(1)',
'null',
'undefined',
'true',
'false',
'Infinity',
'NaN',
'{}',
'{valueOf: function(){return 42}}',
'{toString: function(){return "56"}}',
];
//////
function wrap(tag, s) {
if (s && s.join)
s = s.join('');
return '<' + tag + '>' + String(s) + '</' + tag + '>';
}
function table(head, rows) {
return wrap('table', [
wrap('thead', tr(head)),
wrap('tbody', rows.map(tr))
]);
}
function tr(row) {
return wrap('tr', row.map(function (s) {
return wrap('td', s)
}));
}
function val(n) {
return n === true || Number.isNaN(n) || n === "Error" ? wrap('b', n) : String(n);
}
var rows = VALUES.map(function (v) {
var x = eval('(' + v + ')');
return [v].concat(EXPRS.map(function (e) {
try {
return val(eval(e));
} catch {
return val("Error");
}
}));
});
document.body.innerHTML = table(["x"].concat(EXPRS), rows);table { border-collapse: collapse }
tr:nth-child(odd) { background: #fafafa }
td { border: 1px solid #e0e0e0; padding: 5px; font: 12px monospace }
td:not(:first-child) { text-align: right }
thead td { background: #3663AE; color: white }
b { color: red }isNaN 列可能是值得的：例如，isNaN("") 是 false（即被认为是一个数字），但 parseFloat("") 是 NaN，如果你试图在将其传递给 parseFloat 之前使用 isNaN 来验证输入，这可能会导致问题。 - Retsam'{valueOf: function(){return 42}, toString: function(){return "56"}}'添加到列表中。混合结果很有趣。 - murrayju+ 只是写作更短的方式来表示“数字”，而其他复杂的方式只是会在一些边缘情况下出现错误的方式吗？ - Mihail Malostanidis好的，这里是我所知道的一些区别：
空字符串""被计算为0，而parseInt将其计算为NaN。在我看来，一个空字符串应该是NaN。
+'' === 0; //true
isNaN(parseInt('',10)); //true
一元运算符+的行为更像parseFloat，因为它也接受小数。
另一方面，parseInt会在遇到非数字字符时停止解析，比如表示十进制小数点的符号.。
+'2.3' === 2.3; //true
parseInt('2.3',10) === 2; //true
parseInt 和 parseFloat 从左到右解析并构建字符串。如果它们遇到无效字符，则返回已解析的（如果有）数字，如果没有解析为数字则返回NaN。
另一方面，一元的+符号如果整个字符串无法转换为数字，则返回NaN。
parseInt('2a',10) === 2; //true
parseFloat('2a') === 2; //true
isNaN(+'2a'); //true
如@Alex K.的评论所示，parseInt和parseFloat将按字符解析。这意味着十六进制和指数符号将失败，因为x和e被视为非数字组件（至少在基于十进制的情况下）。
但是一元运算符+可以正确地转换它们。
parseInt('2e3',10) === 2; //true. This is supposed to be 2000
+'2e3' === 2000; //true. This one's correct.
parseInt("0xf", 10) === 0; //true. This is supposed to be 15
+'0xf' === 15; //true. This one's correct.
+"0xf" != parseInt("0xf", 10)。 - Alex K.parseInt("0xf") 也会得到15。 - Bergi"2e3"不是表示整数2000的有效方式。但它可以作为一个浮点数被正确地解析：parseFloat("2e3")会返回2000这个答案。而"0xf"则需要至少使用十六进制，这就是为什么parseInt("0xf", 10)返回0，而parseInt("0xf", 16)返回你期望的值15的原因。 - BartMath.floor(-3.5) == -4和~~-3.5 == -3。 - Albin我认为thg435的回答中的表格是全面的，但我们可以用以下模式进行总结：
true转换为1，但将"true"转换为NaN。parseInt对于不是纯数字的字符串更加宽松。parseInt('123abc') === 123，而+则报告NaN。Number将接受有效的十进制数，而parseInt仅删除小数点后的内容。因此，parseInt模仿了C的行为，但可能并不适合评估用户输入。parseInt是一个设计不良的解析器，接受八进制和十六进制输入。一元加号只接受十六进制。falsy值按照在C中有意义的方式转换为Number：null和false都是零。""变成0并没有完全遵循这个约定，但对我来说有足够的意义。
因此，我认为如果您要验证用户输入，则一元加号在除了接受小数之外的所有内容中都具有正确的行为（但在我的实际情况中，我更关心捕获电子邮件输入，而不是userId、完全省略值等），而parseInt则过于宽松。
注意，Node.JS中parseInt比+一元运算符更快， +或|0更快的说法是错误的，只有对于NaN元素才更快。
看看这个例子：
var arg=process.argv[2];
rpt=20000;
mrc=1000;
a=[];
b=1024*1024*1024*1024;
for (var i=0;i<rpt;i++)
a[i]=Math.floor(Math.random()*b)+' ';
t0=Date.now();
if ((arg==1)||(arg===undefined))
for (var j=0;j<mrc;j++) for (var i=0;i<rpt;i++) {
c=a[i]-0;
}
t1=Date.now();
if ((arg==2)||(arg===undefined)) {
for (var j=0;j<mrc;j++) for (var i=0;i<rpt;i++) {
d=a[i]|0;
}
}
t2=Date.now();
if ((arg==3)||(arg===undefined)) {
for (var j=0;j<mrc;j++) for (var i=0;i<rpt;i++) {
e=parseInt(a[i]);
}
}
t3=Date.now();
if ((arg==3)||(arg===undefined)) {
for (var j=0;j<mrc;j++) for (var i=0;i<rpt;i++) {
f=+a[i];
}
}
t4=Date.now();
console.log(a[i-1],c,d,e,f);
console.log('Eseguiti: '+rpt*mrc+' cicli');
console.log('parseInt '+(t3-t2));
console.log('|0 '+(t2-t1));
console.log('-0 '+(t1-t0));
console.log('+ '+(t4-t3));
// 1000000 iterations each one
node test_speed
Testing ~~, time: 5 ms
Testing parseInt with number, time: 25 ms
Testing parseInt with string, time: 386 ms
Testing Math.floor, time: 18 ms
基准测试的源代码：
/* el propósito de este script es evaluar
que expresiones se ejecutan más rápido para así
decidir cuál usar */
main()
async function main(){
let time, x
let number = 23456.23457
let test1 = ()=>{
x = 0
time = Date.now()
for(let i=0;i<1000000;i++){
let op = Math.floor(number / 3600)
x = op
}
console.info("Testing Math.floor, time:", Date.now() - time, "ms")
}
let test2 = ()=>{
x = 0
time = Date.now()
for(let i=0;i<1000000;i++){
let op = parseInt(number / 3600)
x = op
}
console.info("Testing parseInt with number, time:", Date.now() - time, "ms")
}
let test3 = ()=>{
x = 0
time = Date.now()
for(let i=0;i<1000000;i++){
let op = parseInt((number / 3600).toString())
x = op
}
console.info("Testing parseInt with string, time:", Date.now() - time, "ms")
}
let test4 = ()=>{
x = 0
time = Date.now()
for(let i=0;i<1000000;i++){
let op = ~~(number / 3600)
x = op
}
console.info("Testing ~~, time:", Date.now() - time, "ms")
}
test4()
test2()
test3()
test1()
}
也要考虑性能。我很惊讶parseInt在iOS上比一元加号更快 :) 这对于有重度CPU消耗的Web应用程序非常有帮助。作为一个经验法则，我建议JS优化人员从移动性能的角度考虑任何JS运算符而不是另一个。
所以，要先考虑移动端 ;)