这行之间有什么区别：

var a = parseInt("1", 10); // a === 1

这条线

var a = +"1"; // a === 1

此jsperf测试表明，假设适用于node.js !，在当前的chrome版本中，一元运算符要快得多。

如果我尝试转换不是数字的字符串，则都返回NaN：

var b = parseInt("test" 10); // b === NaN
var b = +"test"; // b === NaN

所以我什么时候应该更喜欢使用parseInt一元加号（尤其是在node.js中）？？？

编辑：和双波浪号运算符有~~什么区别？

请参阅此答案以获得更完整的案例集

好吧，这是我知道的一些区别：

• 空字符串的""计算结果为a 0，而其parseInt计算结果为NaN。IMO，空白字符串应为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将被视为非数字组件（至少在base10上）。

  一元+将正确地转换它们。

  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.
  

最终的数字转换表：

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"',

    '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) ? wrap('b', n) : String(n);
}

var rows = VALUES.map(function (v) {
    var x = eval('(' + v + ')');
    return [v].concat(EXPRS.map(function (e) {
        return val(eval(e))
    }));
});

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 }

我相信thg435的答案中的表是全面的，但是我们可以用以下模式进行总结：

• 一元加号不会将所有伪造的值都一样对待，但是它们全都是伪造的。
• 一元加发送true至1，但发送"true"至NaN。
• 另一方面，parseInt对于不是纯数字的字符串，它更为自由。 parseInt('123abc') === 123，而+报告NaN。
• Number将接受有效的十进制数字，而parseInt只删除所有超出十进制的数字。因此parseInt模拟C行为，但对于评估用户输入可能不是理想的。
• 两者都修剪字符串中的空格。
• parseInt解析器设计不良，它接受八进制和十六进制输入。一元加号仅需十六进制。

虚假值转换为Number遵循C：中有意义的值， null并且false均为零。 ""设为0并不太遵循这个约定，但是对我来说足够有意义。

因此，我认为，如果您要验证用户输入，则一元加除接受小数点外，其他所有内容都具有正确的行为（但在我的现实生活中，我对捕获电子邮件输入而不是userId感兴趣，完全省略了值等），而parseInt太宽松了。

请注意，parseInt在Node.JS中比+一元运算符要快，+或| 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));

也要考虑性能。令我感到惊讶的是，parseInt在iOS上胜过一进制：)这仅对CPU消耗大的Web应用程序有用。作为一个经验法则，我建议JS opt-guys从当今的移动性能角度考虑将JS运算符放在另一个运算符上。

因此，请先移动版 ;）