¿Cuáles son las diferencias entre esta línea?

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

y esta linea

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

Esta prueba jsperf muestra que el operador unario es mucho más rápido en la versión actual de Chrome, suponiendo que sea para node.js !?

Si trato de convertir cadenas que no son números, ambos regresan NaN:

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

Entonces, ¿cuándo debería preferir usar parseIntsobre el plus unario (especialmente en node.js) ???

editar : ¿y cuál es la diferencia con el operador de doble tilde ~~?

Consulte esta respuesta para ver un conjunto más completo de casos.

Bueno, aquí hay algunas diferencias que conozco:

• Una cadena vacía se ""evalúa como a 0, mientras que se parseIntevalúa como NaN. En mi opinión, una cadena en blanco debe ser a NaN.

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

• El unario +actúa más como parseFloatya que también acepta decimales.

  parseIntpor otro lado, deja de analizar cuando ve un carácter no numérico, como el punto que pretende ser un punto decimal ..

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

• parseInty parseFloatanaliza y construye la cadena de izquierda a derecha . Si ven un carácter no válido, devuelve lo que se ha analizado (si lo hay) como un número, y NaNsi ninguno se ha analizado como un número.

  El unario, +por otro lado, volverá NaNsi la cadena completa no es convertible a un número.

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

• Como se ve en el comentario de @Alex K. , parseInty parseFloatse analizará por carácter. Esto significa que las notaciones hexadecimales y exponentes fallarán ya que xy ese tratan como componentes no numéricos (al menos en base10).

  Sin +embargo, el unario los convertirá correctamente.

  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.

La mejor tabla de conversión de cualquier número a número:

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 tabla en la respuesta de thg435 creo que es completa, sin embargo, podemos resumir con los siguientes patrones:

• Unary plus no trata todos los valores falsos de la misma manera, pero todos salen como falsos.
• Unary plus envía truea 1, pero "true"a NaN.
• Por otro lado, parseIntes más liberal para cadenas que no son dígitos puros. parseInt('123abc') === 123, mientras que los +informes NaN.
• Numberaceptará números decimales válidos, mientras que parseIntsimplemente descarta todo más allá del decimal. Por lo tanto, parseIntimita el comportamiento de C, pero quizás no sea ideal para evaluar la entrada del usuario.
• Ambos recortan espacios en blanco en cadenas.
• parseInt, al ser un analizador mal diseñado , acepta entrada octal y hexadecimal. Unary plus solo toma hexademical.

Los valores de falsa se convierten a Numberseguir lo que tendría sentido en C: nully falseambos son cero. ""ir a 0 no sigue esta convención pero tiene bastante sentido para mí.

Por lo tanto, creo que si está validando la entrada del usuario, unary plus tiene el comportamiento correcto para todo excepto para aceptar decimales (pero en mi vida real estoy más interesado en capturar la entrada de correo electrónico en lugar de userId, el valor se omite por completo, etc.), mientras que parseInt es demasiado liberal.

Tenga cuidado, parseInt es más rápido que + operador unario en Node.JS, es falso que + o | 0 son más rápidos, son más rápidos solo para elementos NaN.

Mira esto:

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

Considere el rendimiento también. Me sorprendió que parseIntsupere a unary plus en iOS :) Esto es útil solo para aplicaciones web con un gran consumo de CPU. Como regla general, sugeriría que JS opt-guys considere cualquier operador JS sobre otro desde el punto de vista del rendimiento móvil hoy en día.

Entonces, ve primero al móvil ;)