วิธีเปลี่ยน NaN จาก parseInt เป็น 0 สำหรับสตริงว่าง

เป็นไปได้ที่จะคืนค่า 0 แทนที่จะเป็นNaNเมื่อแยกวิเคราะห์ค่าใน JavaScript หรือไม่?

ในกรณีที่สตริงว่างparseIntกลับNaNมา

เป็นไปได้ไหมที่จะทำเช่นนั้นใน JavaScript เพื่อตรวจสอบNaN?

var value = parseInt(tbb) == NaN ? 0 : parseInt(tbb)

หรืออาจมีฟังก์ชั่นอื่นหรือปลั๊กอิน jQuery ซึ่งอาจทำสิ่งที่คล้ายกัน?

var s = '';

var num = parseInt(s) || 0;

เมื่อไม่ได้ใช้กับค่าบูลีนตัวดำเนินการเชิงตรรกะ OR ( ||) จะส่งกลับนิพจน์แรก ( parseInt(s)) หากสามารถประเมินเป็นจริงได้มิฉะนั้นจะส่งคืนนิพจน์ที่สอง (0) ค่าส่งคืนของparseInt('')คือ NaN NaN ประเมินว่าเป็นเท็จดังนั้นnumสิ้นสุดการตั้งค่าเป็น 0

คุณยังสามารถใช้isNaN()ฟังก์ชัน:

var s = ''
var num = isNaN(parseInt(s)) ? 0 : parseInt(s)

Number()ฉันรู้สึกประหลาดใจที่จะไม่เห็นใครพูดถึงการใช้ ได้รับมันจะแยกทศนิยมถ้าให้ดังนั้นจะทำหน้าที่แตกต่างกว่าparseInt()อย่างไรก็ตามมันจะถือว่าฐาน 10 และจะเปลี่ยน "" หรือแม้กระทั่ง "" ในการ 0

สำหรับผู้ที่ไม่ได้ถูก จำกัดparseIntคุณสามารถใช้ตัวดำเนินการระดับบิตหรือ OR (ซึ่งเรียกToInt32ไปยังตัวถูกดำเนินการโดยปริยาย)

var value = s | 0;

// NaN | 0     ==>> 0
// ''  | 0     ==>> 0
// '5' | 0     ==>> 5
// '33Ab' | 0  ==>> 0
// '0x23' | 0  ==>> 35
// 113 | 0     ==>> 113
// -12 | 0     ==>> -12
// 3.9 | 0     ==>> 3

หมายเหตุ: ความแตกต่างจากToInt32 parseInt(เช่นparseInt('33Ab') === 33)

ปัญหา

คำตอบอื่น ๆ ไม่ได้คำนึงถึงว่า0เป็นเท็จดังนั้นจึงจะเป็น 20 ต่อไปนี้แทน 0:

const myNumber = parseInt('0') || 20; // 20

การแก้ไขปัญหา

ฉันเสนอฟังก์ชันตัวช่วยซึ่งแก้ปัญหาส่วนใหญ่ได้:

function getNumber({ value, defaultValue }) {
  const num = parseInt(value, 10);
  return isNaN(num) ? defaultValue : num;
}

ฟังก์ชันตัวช่วยจะให้ผลลัพธ์ดังนี้:

getNumber({ value: "0", defaultValue: 20 }); // 0
getNumber({ value: "2", defaultValue: 20 }); // 2
getNumber({ value: "2.2", defaultValue: 20 }); // 2
getNumber({ value: "any string", defaultValue: 20 }); // 20
getNumber({ value: undefined, defaultValue: 20 }); // 20
getNumber({ value: null, defaultValue: 20 }); // 20
getNumber({ value: NaN, defaultValue: 20 }); // 20
getNumber({ value: false, defaultValue: 20 }); // 20
getNumber({ value: true, defaultValue: 20 }); // 20

งานของคุณสะอาดกว่าการแยกวิเคราะห์ในความคิดของฉันหรือไม่ใช้ตัวดำเนินการ +

var s = '';
console.log(+s);

var s = '1024'
+s
1024

s = 0
+s
0

s = -1
+s
-1

s = 2.456
+s
2.456

s = ''
+s
0

s = 'wtf'
+s
NaN

var value = isNaN(parseInt(tbb)) ? 0 : parseInt(tbb);

ทำการตรวจสอบแยกต่างหากสำหรับสตริงที่ว่างเปล่า (เนื่องจากเป็นกรณีเฉพาะ) และตั้งค่าเป็นศูนย์ในกรณีนี้

คุณสามารถต่อท้าย "0" เพื่อเริ่มต้น แต่แล้วคุณต้องเพิ่มคำนำหน้าเพื่อระบุว่ามันเป็นทศนิยมและไม่ใช่เลขฐานแปด

ทำไมไม่แทนที่ฟังก์ชั่น? ในกรณีนั้นคุณสามารถมั่นใจได้ว่ามันจะกลับมา0ในกรณีของNaN:

(function(original) {
    parseInt = function() {
        return original.apply(window, arguments) || 0;
    };
})(parseInt);

ตอนนี้ที่ใดก็ได้ในรหัสของคุณ:

parseInt('') === 0

ฉันมีปัญหาที่คล้ายกัน (firefox v34) กับสตริงง่ายๆเช่น:

var myInt = parseInt("b4");

ดังนั้นฉันจึงได้แฮ็คอย่างรวดเร็วของ:

var intVal = ("" + val).replace(/[^0-9]/gi, "");

และจากนั้นก็มีความซับซ้อนที่โง่ที่จะจัดการกับ floats + ints สำหรับสิ่งที่ไม่ง่าย:

var myval = "12.34";

function slowParseNumber(val, asInt){
    var ret = Number( ("" + val).replace(/[^0-9\.]/gi, "") );
    return asInt ? Math.floor(ret) : ret;
}
var floatVal = slowParseNumber(myval);

var intVal = slowParseNumber(myval, true);
console.log(floatVal, intVal);

มันจะคืนค่า 0 สำหรับสิ่งต่าง ๆ เช่น:

var intVal = slowParseNumber("b"); // yeilds 0

//////////////////////////////////////////////////////
function ToInt(x){x=parseInt(x);return isNaN(x)?0:x;}
//////////////////////////////////////////////////////
var x = ToInt('');   //->  x=0
    x = ToInt('abc') //->  x=0
    x = ToInt('0.1') //->  x=0
    x = ToInt('5.9') //->  x=5
    x = ToInt(5.9)   //->  x=5
    x = ToInt(5)     //->  x=5

ฉันสร้างต้นแบบ 2 ตัวเพื่อจัดการเรื่องนี้ให้ฉันหนึ่งตัวสำหรับตัวเลขและอีกตัวหนึ่งสำหรับสตริง

// This is a safety check to make sure the prototype is not already defined.
Function.prototype.method = function (name, func) {
    if (!this.prototype[name]) {
        this.prototype[name] = func;
        return this;
    }
};

// returns the int value or -1 by default if it fails
Number.method('tryParseInt', function (defaultValue) {
    return parseInt(this) == this ? parseInt(this) : (defaultValue === undefined ? -1 : defaultValue);
});

// returns the int value or -1 by default if it fails
String.method('tryParseInt', function (defaultValue) {
    return parseInt(this) == this ? parseInt(this) : (defaultValue === undefined ? -1 : defaultValue);
});

หากคุณไม่ต้องการใช้การตรวจสอบความปลอดภัยให้ใช้

String.prototype.tryParseInt = function(){
    /*Method body here*/
};
Number.prototype.tryParseInt = function(){
     /*Method body here*/
};

ตัวอย่างการใช้งาน:

var test = 1;
console.log(test.tryParseInt()); // returns 1

var test2 = '1';
console.log(test2.tryParseInt()); // returns 1

var test3 = '1a';
console.log(test3.tryParseInt()); // returns -1 as that is the default

var test4 = '1a';
console.log(test4.tryParseInt(0));// returns 0, the specified default value

// implicit cast
var value = parseInt(tbb*1); // see original question

คำอธิบายสำหรับผู้ที่ไม่พบว่ามันเล็กน้อย:

การคูณด้วยวิธีการที่เรียกว่า "การส่งโดยนัย" พยายามที่จะเปลี่ยนชนิดของตัวดำเนินการที่ไม่รู้จักเป็น 'หมายเลข' ชนิดดั้งเดิม โดยเฉพาะอย่างยิ่งสตริงว่างจะกลายเป็นหมายเลข 0 ทำให้มันเป็นประเภทที่มีสิทธิ์สำหรับ parseInt () ...

ตัวอย่างที่ดีมากที่ได้รับข้างต้นโดย PirateApp ผู้แนะนำให้ใส่เครื่องหมายบวกเพื่อบังคับให้ JavaScript ใช้การส่งแบบตัวเลขโดยนัย

ด้วยวิธีนี้ทำไมไม่เขียนฟังก์ชั่นและเรียกมันว่าเคยต้องการ ฉันสมมติว่ามันเป็นรายการในเขตข้อมูลฟอร์มเพื่อทำการคำนวณ

var Nanprocessor = function (entry) {
    if(entry=="NaN") {
        return 0;
    } else {
        return entry;
    }
}

 outputfield.value = Nanprocessor(x); 

// where x is a value that is collected from a from field
// i.e say x =parseInt(formfield1.value); 

มีอะไรผิดปกติในการทำเช่นนี้?

นี่เป็นวิธี tryParseInt ที่ฉันใช้นี่ใช้ค่าเริ่มต้นเป็นพารามิเตอร์ที่สองเพื่อให้เป็นสิ่งที่คุณต้องการ

function tryParseInt(str, defaultValue) {
    return parseInt(str) == str ? parseInt(str) : defaultValue;
}

tryParseInt("", 0);//0 
tryParseInt("string", 0);//0 
tryParseInt("558", 0);//558

ฟังก์ชั่นตัวช่วยซึ่งยังอนุญาตให้ใช้ radix

function parseIntWithFallback(s, fallback, radix) {
    var parsed = parseInt(s, radix);
    return isNaN(parsed) ? fallback : parsed;
}

คุณสามารถมีรหัสที่สะอาดมากฉันมีปัญหาที่คล้ายกันและฉันแก้ไขได้โดยใช้:

var a="bcd";
~~parseInt(a);

สำหรับคนอื่นที่กำลังมองหาวิธีแก้ปัญหานี้เพียงใช้: ~~โดยไม่ต้องแยกวิเคราะห์มันเป็นโหมดที่สะอาดที่สุด

var a = 'hello';
var b = ~~a;

ถ้า NaN มันจะคืนค่า 0 แทน

OBS วิธีนี้ใช้ได้เฉพาะจำนวนเต็มเท่านั้น