parseInt vs sunaryplus, 어떤 것을 사용해야 합니까?

parseInt vs sunaryplus, 어떤 것을 사용해야 합니까?

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

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에서)보다?

편집: 그리고 이중 타일드 연산자와의 차이점은 무엇입니까?~~?

궁극적인 임의의 숫자 변환 표:

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"',
    'BigInt(1)',

    '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) || n === "Error" ? wrap('b', n) : String(n);
}

var rows = VALUES.map(function (v) {
    var x = eval('(' + v + ')');
    return [v].concat(EXPRS.map(function (e) {
        try {
            return val(eval(e));
        } catch {
            return val("Error");
        }
    }));
});

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 }

제가 알고 있는 몇 가지 차이점은 다음과 같습니다.

• 문자열 " " """합니다.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
  

• @Alex K.의 댓글에서 보듯,parseInt그리고.parseFloat문자로 구문 분석합니다., 및 입니다.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.
  

제가 생각하는 thg435의 답변의 표는 포괄적이지만 다음과 같은 패턴으로 요약할 수 있습니다.

• 단항 더하기는 모든 거짓 값을 동일하게 취급하지 않지만 모두 거짓 값으로 나옵니다.
• 에서 항단더전송을 전송합니다.true1까지, 하지만"true"NaN.
• 에반면은,parseInt순수 숫자가 아닌 문자열의 경우 더 자유롭습니다.parseInt('123abc') === 123에, 면에반에.+NaN.
• Number수 있는 , 유한십 허진용 반는면 하효를 수반, 면▁will,,parseInt소수점 이하의 모든 것을 떨어뜨릴 뿐입니다.따라서parseIntC 동작을 모방하지만 사용자 입력을 평가하는 데 이상적이지 않을 수 있습니다.
• 둘 다 문자열의 공백을 자릅니다.
• parseInt잘못 설계된 파서로서, 8진수 및 16진수 입력을 허용합니다.단항 더하기는 6진법만 사용합니다.

잘못된 값은 다음으로 변환됩니다.NumberC에서의미것따을릅다니는있가▁what▁would▁following▁in▁c다▁sense니:따릅▁make.null그리고.false둘 다 0입니다."" 것은 이 잘가 됩니다0으로 가는 것은 이 관례를 잘 따르지 않지만 충분히 이해가 됩니다.

따라서 사용자 입력을 검증하고 있다면 단항 플러스는 소수점을 받아들이는 것을 제외한 모든 것에 대해 올바른 동작을 가지고 있다고 생각합니다(하지만 실제 사례에서는 userId, value가 완전히 생략된 등), 구문 분석 대신 이메일 입력을 잡는 것에 더 관심이 있습니다.인트는 너무 자유롭습니다.

조심해, 구문 분석Int가 노드의 + 단항 연산자보다 빠릅니다.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));

parseString 대신 Math.floor(또는 숫자가 양수인 경우 ~~)를 사용하는 것이 좋습니다. +(식)는 parseFloat에 더 가깝기 때문에 범위를 벗어납니다.이 작은 벤치마크를 보십시오.

// 1000000 iterations each one
node test_speed
Testing ~~, time: 5 ms
Testing parseInt with number, time: 25 ms
Testing parseInt with string, time: 386 ms
Testing Math.floor, time: 18 ms

벤치마크 소스 코드:

/* el propósito de este script es evaluar
que expresiones se ejecutan más rápido para así 
decidir cuál usar */

main()
async function main(){
    let time, x 
    let number = 23456.23457
    
    let test1 = ()=>{
        x = 0
        time = Date.now() 
        for(let i=0;i<1000000;i++){
            let op = Math.floor(number / 3600)
            x = op
        }
        console.info("Testing Math.floor, time:", Date.now() - time, "ms")
    }

    let test2 = ()=>{
        x = 0
        time = Date.now() 
        for(let i=0;i<1000000;i++){
            let op = parseInt(number / 3600)
            x = op
        }
        console.info("Testing parseInt with number, time:", Date.now() - time, "ms")
    }

    let test3 = ()=>{
        x = 0
        time = Date.now() 
        for(let i=0;i<1000000;i++){
            let op = parseInt((number / 3600).toString())
            x = op
        }
        console.info("Testing parseInt with string, time:", Date.now() - time, "ms")
    }

    let test4 = ()=>{
        x = 0
        time = Date.now() 
        for(let i=0;i<1000000;i++){
            let op = ~~(number / 3600)
            x = op
        }
        console.info("Testing ~~, time:", Date.now() - time, "ms")
    }
    
    test4()
    test2()
    test3()
    test1()
    
}

성능도 고려해야 합니다.나는 깜짝 놀랐습니다.parseIntiOS에서 batsunary plus :) 이것은 CPU 사용량이 많은 웹 앱에만 유용합니다.일반적으로 저는 JS 옵트가이들에게 요즘 모바일 성능 관점에서 다른 JS 운영자보다 JS 운영자를 고려할 것을 제안합니다.

모바일 우선;)

언급URL : https://stackoverflow.com/questions/17106681/parseint-vs-unary-plus-when-to-use-which