이 줄의 차이점은 무엇입니까?

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

이 라인

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

이 jsperf 테스트 는 node.js에 대한 가정하에 단항 연산자가 현재 크롬 버전에서 훨씬 빠르다는 것을 보여줍니다.

숫자가 아닌 문자열을 변환하려고하면 둘 다 반환됩니다 NaN.

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

그렇다면 parseInt단항 플러스 (특히 node.js)를 사용하는 것을 선호해야합니까 ???

편집 : 이중 물결표 연산자의 차이점은 무엇 ~~입니까?

보다 완벽한 사례 집합에 대해서는 이 답변 을 참조하십시오

글쎄, 여기에 내가 아는 몇 가지 차이점이 있습니다.

• 빈 문자열 ""A를 평가 0하면서, parseInt평가하여 그것 NaN. IMO, 빈 문자열은이어야합니다 NaN.

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

• 단항 은 소수를 허용하기 때문에 +더 유사하게 작동 parseFloat합니다.

  parseInt반면에 소수점이되는 마침표와 같이 숫자가 아닌 문자가 표시되면 구문 분석이 중지됩니다 ..

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

• parseInt및 parseFloat분석하고 문자열 빌드 왼쪽에서 오른쪽을 . 유효하지 않은 문자가 표시되면 구문 분석 된 항목 (있는 경우)을 숫자로, NaN구문 분석 된 것이없는 경우 숫자로 반환합니다 .

  반면에 단항 전체 문자열을 숫자로 변환 할 수 없으면 단항 +이 반환 NaN됩니다.

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

• 바와 같이의 코멘트에서 볼 @ 알렉스 K. , parseInt그리고 parseFloat문자로 해석됩니다. 이것은 16 진법과 지수 표기법이 실패 x하고 e숫자가 아닌 성분 (적어도 10 진법 이상)으로 취급됨을 의미합니다.

  단항 +은 제대로 변환합니다.

  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.

최고의 숫자 변환 표 :

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의 답변에있는 표는 포괄적이지만 다음과 같은 패턴으로 요약 할 수 있습니다.

• 단항 더하기는 모든 허위 값을 동일하게 취급하지는 않지만 모두 허위로 나옵니다.
• 단항 플러스 전송 true1 만 "true"에 NaN.
• 반면에 parseInt순수한 숫자가 아닌 문자열에 대해서는 더 자유 롭습니다. parseInt('123abc') === 123반면에 +보고합니다 NaN.
• Number유효한 십진수를 허용하는 반면 parseInt소수를 지나서 모든 것을 삭제합니다. 따라서 parseIntC 동작을 모방하지만 사용자 입력을 평가하는 데 적합하지 않을 수 있습니다.
• 둘 다 문자열에서 공백을 다듬습니다.
• parseInt잘못 설계된 파서 인 8 진수 및 16 진수 입력을 허용합니다. 단항 플러스는 16 진법 만 사용합니다.

Falsy 값으로 변환 Number: C에서 의미가 될지 다음 null과 false양쪽 모두 0이다. ""0으로 이동하면이 규칙을 따르지 않지만 충분히 이해됩니다.

따라서 사용자 입력의 유효성을 검사하는 경우 단항 더하기에는 소수점 이하 자릿수를 제외한 모든 항목에 대해 올바른 동작이 있다고 생각합니다 (그러나 실제 경우에는 userId 대신 이메일 입력을 잡는 데 더 관심이 있습니다. parseInt가 너무 자유 롭습니다.

parseInt가 Node.JS에서 + 단항 연산자보다 빠르다는 점에주의하십시오. + 또는 | 0이 빠르면 NaN 요소에 대해서만 더 빠릅니다.

이것 좀 봐:

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

성능 도 고려하십시오 . parseIntiOS에서 단항 플러스 를 능가 한다고 놀랐습니다. : 이것은 CPU 소비가 많은 웹 앱에만 유용합니다. 일반적으로 JS opt-guys는 요즘 모바일 성능 관점에서 JS 운영자를 다른 운영자보다 고려할 것을 제안합니다.

따라서 모바일 우선 ;)