Quali sono le differenze tra questa linea:

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

e questa linea

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

Questo test jsperf mostra che l'operatore unario è molto più veloce nell'attuale versione di Chrome, supponendo che sia per node.js !?

Se provo a convertire stringhe che non sono numeri, entrambi restituiscono NaN:

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

Quindi, quando dovrei preferire usare parseIntil plus unario (specialmente in node.js) ???

modifica : e qual è la differenza per l'operatore double tilde ~~?

Si prega di consultare questa risposta per un set più completo di casi

Bene, ecco alcune differenze che conosco:

• Una stringa vuota restituisce ""a 0, mentre la parseIntvaluta in NaN. IMO, una stringa vuota dovrebbe essere a NaN.

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

• L'unario si +comporta in modo più simile parseFloatpoiché accetta anche i decimali.

  parseIntd'altra parte smette di analizzare quando vede un carattere non numerico, come il punto che deve essere un punto decimale ..

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

• parseInte parseFloatanalizza e costruisce la stringa da sinistra a destra . Se visualizzano un carattere non valido, restituisce ciò che è stato analizzato (se presente) come numero e NaNse nessuno è stato analizzato come numero.

  Il unario +d'altra parte restituirà NaNse l'intera stringa non è convertibile in un numero.

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

• Come visto nel commento di @Alex K. , parseInte parseFloatanalizzerà per carattere. Ciò significa che le notazioni esadecimali ed esponenziali falliranno poiché i xe evengono trattati come componenti non numerici (almeno su base10).

  L'unario +li convertirà correttamente però.

  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.

L'ultima tabella di conversione da qualunque numero:

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 }

La tabella nella risposta di thg435 credo sia completa, tuttavia possiamo riassumere con i seguenti schemi:

• Unary plus non tratta tutti i valori di falsa allo stesso modo, ma tutti ne risultano falsi.
• Unary plus invia truea 1, ma "true"a NaN.
• D'altra parte, parseIntè più liberale per le stringhe che non sono cifre pure. parseInt('123abc') === 123, mentre +rapporti NaN.
• Numberaccetterà numeri decimali validi, mentre parseIntsemplicemente trascina tutto oltre il decimale. Quindi parseIntimita il comportamento di C, ma forse non è l'ideale per valutare l'input dell'utente.
• Entrambi gli spazi bianchi vengono tagliati nelle stringhe.
• parseInt, essendo un parser mal progettato , accetta input ottali ed esadecimali. Unary plus richiede solo hexademical.

I valori falsi si convertono nel Numberseguire ciò che avrebbe senso in C: nulle falsesono entrambi zero. ""andare a 0 non segue del tutto questa convenzione, ma per me ha abbastanza senso.

Pertanto penso che se stai convalidando l'input dell'utente, unary plus ha un comportamento corretto per tutto tranne che accetta i decimali (ma nella mia vita reale sono più interessato a catturare l'input e-mail invece di userId, il valore omesso del tutto, ecc.), Mentre parseInt è troppo liberale.

Attenzione, parseInt è più veloce di + operatore unario in Node.JS, è falso che + o | 0 sono più veloci, sono più veloci solo per gli elementi NaN.

Controllalo:

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

Considera anche le prestazioni . Sono stato sorpreso che parseIntbatte unario in più su iOS :) Questo è utile solo per le app Web con un consumo elevato di CPU. Come regola empirica suggerirei ai opt-boys di JS di considerare qualsiasi operatore JS piuttosto che un altro dal punto di vista delle prestazioni mobili al giorno d'oggi.

Quindi, passa al primo cellulare ;)