Bagaimana mengubah NaN dari parseInt menjadi 0 untuk string kosong?

Apakah mungkin entah bagaimana mengembalikan 0 alih-alih NaNsaat menguraikan nilai dalam JavaScript?

Dalam kasus string kosong parseIntkembali NaN.

Apakah mungkin untuk melakukan hal seperti itu di JavaScript untuk memeriksanya NaN?

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

Atau mungkin ada fungsi lain atau plugin jQuery yang dapat melakukan hal serupa?

var s = '';

var num = parseInt(s) || 0;

Ketika tidak digunakan dengan nilai boolean, ||operator logika OR ( ) mengembalikan ekspresi pertama ( parseInt(s)) jika dapat dievaluasi menjadi true, jika tidak maka mengembalikan ekspresi kedua (0). Nilai kembali parseInt('')adalah NaN. NaN dievaluasi menjadi false, sehingga numakhirnya ditetapkan ke 0.

Anda juga dapat menggunakan isNaN()fungsi ini:

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

Saya terkejut tidak melihat ada yang menyebutkan menggunakan Number(). Mengabulkannya akan menguraikan desimal jika disediakan, jadi akan bertindak berbeda dari parseInt(), namun itu sudah mengasumsikan basis 10 dan akan berubah "" atau bahkan "" menjadi 0.

Untuk orang-orang yang tidak dibatasi parseInt, Anda dapat menggunakan operator ATAU bitwise (yang secara implisit memanggil ToInt32operannya).

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

Catatan: ToInt32berbeda dari parseInt. (yaitu parseInt('33Ab') === 33)

Masalah

Jawaban lain tidak memperhitungkan yang 0salah, dan dengan demikian yang berikut adalah 20 bukannya 0:

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

Solusinya

Saya mengusulkan fungsi pembantu, yang memecahkan sebagian besar masalah:

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

Fungsi helper akan memberikan hasil berikut:

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

Apakah pekerjaannya jauh lebih bersih daripada parseInt menurut saya, Gunakan operator +

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

Lakukan pemeriksaan terpisah untuk string kosong (karena ini adalah satu kasus khusus) dan setel ke nol dalam kasus ini.

Anda dapat menambahkan "0" ke awal, tetapi kemudian Anda perlu menambahkan awalan untuk menunjukkan bahwa itu adalah desimal dan bukan angka oktal

Mengapa tidak mengganti fungsi? Dalam hal ini, Anda selalu dapat memastikan itu kembali 0jika NaN:

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

Sekarang, di mana saja dalam kode Anda:

parseInt('') === 0

Saya punya masalah yang sama (firefox v34) dengan string sederhana seperti:

var myInt = parseInt("b4");

Jadi saya datang dengan retasan cepat:

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

Dan kemudian menjadi sangat rumit untuk berurusan dengan mengapung + int untuk hal-hal yang tidak sederhana:

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

Ini akan mengembalikan 0 untuk hal-hal seperti:

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

Saya membuat 2 prototipe untuk menangani ini untuk saya, satu untuk nomor, dan satu untuk sebuah String.

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

Jika Anda tidak ingin menggunakan pemeriksaan keamanan, gunakan

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

Contoh penggunaan:

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

Penjelasan, bagi mereka yang tidak menganggapnya sepele:

Mengalikan dengan satu, metode yang disebut "pemain implisit", mencoba untuk mengubah operan tipe yang tidak dikenal menjadi tipe 'nomor' primitif. Secara khusus, string kosong akan menjadi nomor 0, menjadikannya tipe yang memenuhi syarat untuk parseInt () ...

Contoh yang sangat bagus juga diberikan di atas oleh PirateApp, yang menyarankan untuk menambahkan tanda +, memaksa JavaScript untuk menggunakan pemeran tersirat Number.

Juga dengan cara ini, mengapa tidak menulis fungsi dan menyebutnya di mana pun diperlukan. Saya berasumsi itu adalah entri ke bidang formulir untuk melakukan perhitungan.

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

apa yang salah melakukan ini?

Berikut adalah metode tryParseInt yang saya gunakan, ini mengambil nilai default sebagai parameter kedua sehingga bisa apa saja yang Anda butuhkan.

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

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

fungsi pembantu yang masih memungkinkan untuk menggunakan radix

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

Anda dapat memiliki kode yang sangat bersih, saya memiliki masalah yang sama dan saya menyelesaikannya dengan menggunakan:

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

Untuk orang lain yang mencari solusi ini, cukup gunakan: ~~ tanpa parseInt, ini adalah mode terbersih.

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

Jika NaN, itu akan mengembalikan 0 sebagai gantinya.

OBS. Solusi ini hanya berlaku untuk bilangan bulat