อะไรคือความแตกต่างระหว่างบรรทัดนี้:

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

และสายนี้

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

การทดสอบ jsperfนี้แสดงให้เห็นว่าโอเปอเรเตอร์ unary นั้นเร็วกว่ามากในรุ่นโครมปัจจุบันโดยสมมติว่ามันใช้สำหรับ node.js !?

ถ้าฉันพยายามแปลงสตริงที่ไม่ใช่ตัวเลขทั้งสองคืนNaN:

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

ดังนั้นเมื่อไรฉันจึงควรใช้งานparseIntมากกว่า unary plus (โดยเฉพาะใน node.js) ???

แก้ไข : และผู้ประกอบการตัวหนอนสองตัวที่แตกต่างกัน~~คืออะไร?

โปรดดูคำตอบนี้สำหรับกรณีที่สมบูรณ์มากขึ้น

นี่คือความแตกต่างเล็กน้อยที่ฉันรู้:

• สตริงที่ว่างเปล่า""ประเมินไป0ในขณะที่ประเมินว่ามันparseInt NaNIMO NaNสตริงว่างเปล่าควรจะเป็น

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

• เอกภาพ+ทำหน้าที่คล้ายกันมากขึ้นparseFloatเพราะมันยังยอมรับทศนิยม

  parseIntบนมืออื่น ๆ .หยุดการแยกเมื่อเห็นตัวละครที่ไม่ใช่ตัวเลขเช่นระยะเวลาที่มีวัตถุประสงค์เพื่อเป็นจุดทศนิยม

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

• parseIntและparseFloatจะแยกวิเคราะห์และสร้างสตริงจากซ้ายไปขวา หากพวกเขาเห็นอักขระที่ไม่ถูกต้องมันจะส่งคืนสิ่งที่ถูกวิเคราะห์คำ (ถ้ามี) เป็นตัวเลขและNaNหากไม่มีการแยกวิเคราะห์เป็นตัวเลข

  unary +ในอีกทางหนึ่งจะส่งคืนNaNถ้าสตริงทั้งหมดไม่สามารถแปลงเป็นตัวเลขได้

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

• เท่าที่เห็นในความคิดเห็นของ@ Alex เค , parseIntและparseFloatจะแยกตัวอักษร ซึ่งหมายความว่าการแสดงเลขฐานสิบหกและสัญลักษณ์เลขชี้กำลังจะล้มเหลวเนื่องจากxและeถือว่าเป็นองค์ประกอบที่ไม่ใช่ตัวเลข (อย่างน้อยบน base10)

  เอก+จะเปลี่ยนพวกเขาอย่างถูกต้องแม้ว่า

  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 ฉันเชื่อว่าครอบคลุม แต่เราสามารถสรุปด้วยรูปแบบต่อไปนี้:

• ยูนารีพลัสไม่ได้ปฏิบัติต่อค่าที่ผิดทั้งหมดเหมือนกัน
• เอกบวกส่งtrueไป 1 แต่จะ"true"NaN
• ในทางกลับกันparseIntก็มีเสรีมากขึ้นสำหรับสตริงที่ไม่ใช่ตัวเลขที่บริสุทธิ์ parseInt('123abc') === 123ในขณะที่รายงาน+NaN
• Numberจะยอมรับตัวเลขทศนิยมที่ถูกต้องในขณะที่parseIntลดลงทุกอย่างผ่านทศนิยม ดังนั้นparseIntเลียนแบบพฤติกรรม C แต่อาจไม่เหมาะสำหรับการประเมินอินพุตของผู้ใช้
• ทั้งตัดช่องว่างในสตริง
• parseIntเป็นตัวแยกวิเคราะห์ที่ออกแบบมาไม่ดียอมรับอินพุตแปดและฐานสิบหก เอกภาพบวกใช้เวลาเพียงเฮกซะเคมี

ค่า Falsy แปลงเป็นค่าที่Numberตามมาใน C: nullและfalseทั้งคู่เป็นศูนย์ ""ไปที่ 0 ไม่ได้ทำตามอนุสัญญานี้ แต่สมเหตุสมผลสำหรับฉัน

ดังนั้นฉันคิดว่าถ้าคุณกำลังตรวจสอบการป้อนข้อมูลของผู้ใช้ unary plus มีพฤติกรรมที่ถูกต้องสำหรับทุกอย่างยกเว้นมันรับทศนิยม parseInt มีแนวคิดเสรีเกินไป

ระวัง, parseInt เร็วกว่า + ตัวดำเนินการ unary ในโหนด 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));

พิจารณาประสิทธิภาพด้วย ฉันประหลาดใจที่parseIntเต้น unary plus บน iOS :) สิ่งนี้มีประโยชน์สำหรับเว็บแอปที่มีการใช้ CPU มากเท่านั้น ในฐานะกฎของหัวแม่มือฉันแนะนำให้ JS opt-guys พิจารณาผู้ให้บริการ JS มากกว่าอีกคนหนึ่งจากมุมมองประสิทธิภาพมือถือในปัจจุบัน

ดังนั้นไปที่มือถือก่อน ;)