parseInt - unary plus, hangisi ne zaman kullanılır?

Bu satır arasındaki farklar nelerdir:

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

ve bu çizgi

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

Bu jsperf testi , node.js için olduğu varsayılarak, tekli operatörün mevcut krom sürümünde çok daha hızlı olduğunu gösterir !?

Sayı olmayan dizeleri dönüştürmeye çalışırsam, her ikisi de şunu döndürür NaN:

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

Öyleyse ne zaman parseInttekli artı kullanmayı tercih etmeliyim (özellikle node.js'de) ???

düzenleme : ve çift tilde operatöründen farkı ~~nedir?

# Daha eksiksiz bir vaka kümesi için lütfen bu yanıta bakın

İşte bildiğim birkaç farklılık:

• Boş bir dize "", a olarak değerlendirilirken 0, olarak parseIntdeğerlendirilir NaN. IMO, boş bir dize bir NaN.

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

• Tekli , ondalık sayıları da kabul ettiği için +daha çok davranır parseFloat.

  parseIntÖte yandan, ondalık nokta olması amaçlanan nokta gibi sayısal olmayan bir karakter gördüğünde ayrıştırmayı durdurur ..

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

• parseIntve parseFloatdizeyi soldan sağa ayrıştırır ve oluşturur . Geçersiz bir karakter görürlerse, ayrıştırılmış olanı (varsa) sayı olarak ve NaNhiçbiri sayı olarak çözümlenmemişse döndürür .

  +Öte yandan tekli , NaNdizenin tamamı bir sayıya dönüştürülemiyorsa geri dönecektir .

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

• As yorumda görülen @Alex K. , parseIntve parseFloatkarakteriyle ayrıştırmak edecektir. Bu, onaltılı ve üslü gösterimlerin başarısız olacağı anlamına gelir, çünkü xve esayısal olmayan bileşenler olarak değerlendirilir (en azından baz10'da).

  Tekli +onları doğru bir şekilde dönüştürecektir.

    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.
  

Nihai sayıdan sayıya dönüştürme tablosu:

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'in cevabındaki tablonun kapsamlı olduğuna inanıyorum, ancak aşağıdaki kalıplarla özetleyebiliriz:

• Unary plus, tüm yanlış değerlere aynı şekilde davranmaz, ancak hepsi yanlış çıkar.
• Birli artı gönderir true1'e ama "true"hiç NaN.
• Öte yandan, parseIntsalt rakam olmayan dizeler için daha liberaldir. parseInt('123abc') === 123, oysa +raporlar NaN.
• Numbergeçerli ondalık sayıları kabul ederken, parseIntyalnızca ondalık sayıları aşan her şeyi bırakır. Bu nedenle parseIntC davranışını taklit eder, ancak kullanıcı girdisini değerlendirmek için belki de ideal değildir.
• Her ikisi de dizelerdeki boşlukları keser.
• parseIntkötü tasarlanmış bir ayrıştırıcı olduğundan sekizlik ve onaltılık girdileri kabul eder. Tekli artı yalnızca onaltılı alır.

Yanlış değerler Number, C: ' de mantıklı olan aşağıdakilere dönüşür nullve falseher ikisi de sıfırdır. ""0'a gitmek bu düzene tam olarak uymuyor ama bana yeterince mantıklı geliyor.

Bu nedenle, kullanıcı girdisini doğruluyorsanız, unary plus'ın ondalık sayıları kabul etmesi dışında her şey için doğru davranışa sahip olduğunu düşünüyorum (ancak gerçek hayattaki durumumda, userId yerine e-posta girdisini yakalamakla daha çok ilgileniyorum, değer tamamen atlandı vb.) parseInt çok liberal.

Dikkatli olun, node.JS'de parseInt + tekli operatörden daha hızlıdır, + veya | 0'ın daha hızlı olduğu yanlıştır, yalnızca NaN öğeleri için daha hızlıdır.

Şuna bir bak:

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

Performansı da düşünün . Şaşırmıştım kiparseIntİOS'ta unary plus'ı geçmesi :) Bu, yalnızca yoğun CPU tüketimi olan web uygulamaları için yararlıdır. Genel bir kural olarak, JS'yi tercih edenlerin günümüzde mobil performans açısından herhangi bir JS operatörünü başka bir operatör yerine değerlendirmelerini öneririm.

Öyleyse, mobil cihazlara öncelik verin ;)