Quais são as diferenças entre esta linha:

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

e esta linha

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

Este teste jsperf mostra que o operador unário é muito mais rápido na versão atual do chrome, assumindo que é para o node.js.?

Se eu tentar converter strings que não são números, ambos retornam NaN:

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

Então, quando devo preferir usar parseInto plus unário (especialmente no node.js) ???

edit : e qual a diferença para o operador double til ~~?

Por favor, veja esta resposta para um conjunto mais completo de casos

Bem, aqui estão algumas diferenças que eu conheço:

• Uma cadeia vazia é ""avaliada como a 0, enquanto é parseIntavaliada como NaN. IMO, uma string em branco deve ser a NaN.

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

• O unário +age mais como parseFloatuma vez que também aceita decimais.

  parseIntpor outro lado, para de analisar quando vê um caractere não numérico, como o período que se destina a ser um ponto decimal ..

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

• parseInte parseFloatanalisa e constrói a string da esquerda para a direita . Se eles virem um caractere inválido, ele retornará o que foi analisado (se houver) como um número e NaNse nenhum foi analisado como um número.

  O unário, +por outro lado, retornará NaNse a sequência inteira não for convertível em um número.

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

• Como visto no comentário de @Alex K. , parseInte parseFloatanalisará por caractere. Este hex meios e notações expoente falhará desde o xe esão tratados como componentes não numéricos (pelo menos em Base10).

  O unário +irá convertê-los corretamente embora.

  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.

A melhor tabela de conversão para qualquer 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 }

A tabela na resposta de thg435 que acredito ser abrangente, no entanto, podemos resumir com os seguintes padrões:

• O Unary plus não trata todos os valores falsos da mesma forma, mas todos saem falsificados.
• Unary plus envia truepara 1, mas "true"para NaN.
• Por outro lado, parseInté mais liberal para strings que não são dígitos puros. parseInt('123abc') === 123, enquanto que +relatórios NaN.
• Numberaceitará números decimais válidos, enquanto parseIntapenas ignora tudo além do decimal. Assim, parseIntimita o comportamento C, mas talvez não seja ideal para avaliar a entrada do usuário.
• Ambos cortam o espaço em branco nas cadeias.
• parseInt, sendo um analisador mal projetado , aceita entrada octal e hexadecimal. Unary plus leva apenas hexadecimal.

Os valores de falsidade se convertem em Numberseguir o que faria sentido em C: nulle falsesão zero. ""ir para 0 não segue essa convenção, mas faz bastante sentido para mim.

Portanto, acho que se você está validando a entrada do usuário, o unary plus tem um comportamento correto para tudo, exceto que ele aceita decimais (mas, nos meus casos da vida real, estou mais interessado em capturar entrada de email em vez de userId, valor omitido inteiramente etc.), enquanto parseInt é muito liberal.

Cuidado, parseInt é mais rápido que o operador unário no Node.JS, é falso que + ou | 0 sejam mais rápidos, eles são mais rápidos apenas para elementos NaN.

Veja isso:

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 o desempenho também. Fiquei surpreso que parseIntsupere o unário e mais no iOS :) Isso é útil para aplicativos da Web com alto consumo de CPU. Como regra geral, sugiro que os JS opt-guys considerem qualquer operador JS em detrimento de outro do ponto de vista do desempenho móvel atualmente.

Então, vá para o celular primeiro ;)