Sự khác biệt giữa dòng này là gì:

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

và dòng này

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

Thử nghiệm jsperf này cho thấy toán tử đơn nguyên nhanh hơn nhiều trong phiên bản chrome hiện tại, giả sử nó là dành cho node.js!?

Nếu tôi cố gắng chuyển đổi các chuỗi không phải là số cả hai trả về NaN:

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

Vậy khi nào tôi nên sử dụng parseInthơn unary plus (đặc biệt là trong node.js) ???

chỉnh sửa : và sự khác biệt đối với toán tử dấu ngã kép là ~~gì?

Xin vui lòng xem câu trả lời này cho một bộ trường hợp đầy đủ hơn

Vâng, đây là một vài sự khác biệt tôi biết:

• Một chuỗi rỗng ""đánh giá đến a 0, trong khi parseIntđánh giá nó thành NaN. IMO, một chuỗi trống phải là a NaN.

  +'' === 0;              //true
  isNaN(parseInt('',10)); //true

• Các unary +hành động giống như parseFloatvì nó cũng chấp nhận số thập phân.

  parseIntmặt khác dừng phân tích cú pháp khi thấy một ký tự không phải là số, giống như khoảng thời gian được dự định là dấu thập phân ..

  +'2.3' === 2.3;           //true
  parseInt('2.3',10) === 2; //true

• parseIntvà parseFloatphân tích cú pháp và xây dựng chuỗi từ trái sang phải . Nếu họ thấy một ký tự không hợp lệ, nó sẽ trả về những gì đã được phân tích cú pháp (nếu có) dưới dạng một số và NaNnếu không được phân tích thành một số.

  Mặt khác, unary +sẽ trả về NaNnếu toàn bộ chuỗi không chuyển đổi thành số.

  parseInt('2a',10) === 2; //true
  parseFloat('2a') === 2;  //true
  isNan(+'2a');            //true

• Như đã thấy trong bình luận của @Alex K. , parseIntvà parseFloatsẽ phân tích theo ký tự. Điều này có nghĩa là các ký hiệu hex và số mũ sẽ thất bại vì xvà eđược coi là các thành phần không phải là số (ít nhất là trên cơ sở 10).

  Các unary +sẽ chuyển đổi chúng đúng cách mặc dù.

  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.

Bảng chuyển đổi mọi thứ thành số cuối cùng:

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 }

Bảng trong câu trả lời của Jun435 tôi tin là toàn diện, tuy nhiên chúng ta có thể tóm tắt với các mẫu sau:

• Unary plus không đối xử với tất cả các giá trị giả như nhau, nhưng tất cả chúng đều xuất hiện sai lệch.
• Unary plus gửi truetới 1, nhưng "true"đến NaN.
• Mặt khác, parseInttự do hơn cho các chuỗi không phải là chữ số thuần túy. parseInt('123abc') === 123, trong khi +báo cáo NaN.
• Numbersẽ chấp nhận số thập phân hợp lệ, trong khi parseIntchỉ bỏ mọi thứ qua số thập phân. Do đó, parseIntbắt chước hành vi C, nhưng có lẽ không lý tưởng để đánh giá đầu vào của người dùng.
• Cả hai cắt khoảng trắng trong chuỗi.
• parseInt, là một trình phân tích cú pháp được thiết kế xấu , chấp nhận đầu vào bát phân và thập lục phân. Unary plus chỉ mất hexademical.

Các giá trị giả sẽ chuyển đổi Numbertheo sau những gì có ý nghĩa trong C: nullvà falseđều bằng không. ""về 0 không hoàn toàn tuân theo quy ước này nhưng đủ ý nghĩa với tôi.

Do đó, tôi nghĩ rằng nếu bạn đang xác thực đầu vào của người dùng, unary plus có hành vi đúng cho mọi thứ trừ việc nó chấp nhận số thập phân (nhưng trong trường hợp thực tế của tôi, tôi quan tâm hơn đến việc bắt đầu vào email thay vì userId, giá trị bị bỏ qua hoàn toàn, v.v.), trong khi parseInt là quá tự do.

Hãy cẩn thận, parseInt nhanh hơn + toán tử đơn nguyên trong Node.JS, thật sai khi + hoặc | 0 nhanh hơn, chúng chỉ nhanh hơn đối với các phần tử NaN.

Kiểm tra này:

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

Xem xét hiệu suất quá. Tôi đã ngạc nhiên khi parseIntđánh bại unary plus trên iOS :) Điều này hữu ích cho các ứng dụng web chỉ tiêu thụ CPU nặng. Như một quy tắc chung, tôi đề nghị những người chọn tham gia JS xem xét bất kỳ toán tử JS nào khác so với quan điểm hiệu suất di động hiện nay.

Vì vậy, hãy di động trước ;)