Apa perbedaan antara baris ini:

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

dan baris ini

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

Tes jsperf ini menunjukkan bahwa operator unary jauh lebih cepat dalam versi chrome saat ini, dengan asumsi itu untuk node.js !?

Jika saya mencoba mengonversi string yang bukan angka, keduanya kembali NaN:

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

Jadi kapan saya lebih suka menggunakan parseIntlebih dari unary plus (terutama di node.js) ???

edit : dan apa bedanya dengan operator double tilde ~~?

Silakan lihat jawaban ini untuk satu set kasus yang lebih lengkap

Nah, inilah beberapa perbedaan yang saya ketahui:

• String kosong ""mengevaluasi ke 0, sedangkan parseIntmengevaluasinya ke NaN. IMO, string kosong harus a NaN.

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

• Unary +bertindak lebih seperti parseFloatkarena ia juga menerima desimal.

  parseIntdi sisi lain berhenti parsing ketika melihat karakter non-numerik, seperti periode yang dimaksudkan sebagai titik desimal ..

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

• parseIntdan parseFloatmem - parsing dan membuat string dari kiri ke kanan . Jika mereka melihat karakter yang tidak valid, itu mengembalikan apa yang telah diuraikan (jika ada) sebagai angka, dan NaNjika tidak ada yang diuraikan sebagai angka.

  Unary +di sisi lain akan kembali NaNjika seluruh string tidak dapat dikonversi menjadi angka.

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

• Seperti yang terlihat di komentar @Alex K. , parseIntdan parseFloatakan diuraikan berdasarkan karakter. Ini berarti notasi heks dan eksponen akan gagal karena xdan ediperlakukan sebagai komponen non-numerik (setidaknya pada basis10).

  Unary +akan mengubahnya dengan benar.

  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.

Tabel konversi berapapun jumlah pamungkas:

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 }

Tabel dalam jawaban thg435 yang saya yakini komprehensif, namun kita dapat merangkum dengan pola-pola berikut:

• Unary plus tidak memperlakukan semua nilai falsy sama, tetapi semuanya keluar falsy.
• Unary plus mengirim trueke 1, tetapi "true"ke NaN.
• Di sisi lain, parseIntlebih liberal untuk string yang bukan digit murni. parseInt('123abc') === 123, sedangkan +laporan NaN.
• Numberakan menerima angka desimal yang valid, sedangkan parseInthanya menjatuhkan semua yang melewati desimal. Dengan demikian parseIntmeniru perilaku C, tetapi mungkin tidak ideal untuk mengevaluasi input pengguna.
• Keduanya memangkas spasi putih dalam string.
• parseInt, sebagai pengurai yang dirancang dengan buruk , menerima input oktal dan heksadesimal. Unary plus hanya membutuhkan hexademical.

Nilai-nilai palsu dikonversi untuk Numbermengikuti apa yang masuk akal dalam C: nulldan falsekeduanya nol. ""pergi ke 0 tidak cukup mengikuti konvensi ini tetapi cukup masuk akal bagi saya.

Karena itu saya pikir jika Anda memvalidasi input pengguna, unary plus memiliki perilaku yang benar untuk semuanya kecuali menerima desimal (tetapi dalam kasus kehidupan nyata saya, saya lebih tertarik untuk menangkap input email daripada userId, nilai dihilangkan seluruhnya, dll.), Sedangkan parseInt terlalu liberal.

Hati-hati, parseInt lebih cepat dari + operator unary di Node.JS, salah bahwa + atau | 0 lebih cepat, mereka lebih cepat hanya untuk elemen NaN.

Lihat ini:

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

Pertimbangkan kinerja juga. Saya terkejut bahwa parseIntmengalahkan unary plus di iOS :) Ini membantu untuk aplikasi web dengan konsumsi CPU saja. Sebagai aturan umum saya menyarankan JS opt-guys untuk mempertimbangkan operator JS lebih dari operator lain dari sudut pandang kinerja mobile saat ini.

Jadi, go mobile-first ;)