这行有什么区别：
var a = parseInt("1", 10); // a === 1
和这条线
var a = +"1"; // a === 1
这个jsperf 测试表明一元运算符在当前的 chrome 版本中要快得多，假设它是用于 node.js！？
如果我尝试转换不是数字的字符串都返回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.
我认为 thg435 的答案中的表格很全面，但是我们可以总结为以下模式：
true到 1，但发送"true"到NaN。parseInt对于非纯数字的字符串则更为宽松。 parseInt('123abc') === 123，而+报告NaN。Number将接受有效的十进制数，而parseInt只会删除小数点之后的所有内容。因此parseInt模仿 C 的行为，但可能不适合评估用户输入。parseInt，作为一个设计糟糕的解析器，接受八进制和十六进制输入。一元加只取十六进制。Falsy 值转换为Number以下在 C: 中有意义的 值null，false并且都为零。 ""转到 0 并不完全遵循这个约定，但对我来说已经足够了。
因此，我认为如果您正在验证用户输入，除了接受小数之外，一元加号对所有内容都有正确的行为（但在我的现实生活中，我更感兴趣的是捕获电子邮件输入而不是 userId、完全省略值等），而parseInt 太自由了。
我建议使用 Math.floor（或者 ~~ 如果你知道数字是正数）而不是 parseString。+(expression) 超出了范围，因为 +(expression) 更像 parseFloat。看看这个小基准：
// 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()
}
请注意，在 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));