Boş bir dize için parseInt'ten NaN'yi 0'a nasıl dönüştürebilirim?

NaNJavaScript'te değerleri ayrıştırmak yerine bir şekilde 0 döndürmek mümkün mü ?

Boş dize durumunda parseIntdöner NaN.

Kontrol etmek için JavaScript'te böyle bir şey yapmak mümkün mü NaN?

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

Ya da benzer bir şey yapabilen başka bir işlev veya jQuery eklentisi var mı?

var s = '';

var num = parseInt(s) || 0;

Boole değerleriyle kullanılmadığında, mantıksal OR ( ||) operatörü parseInt(s)true olarak değerlendirilebiliyorsa ilk ifadeyi ( ) döndürür, aksi takdirde ikinci ifadeyi (0) döndürür. Dönüş değeri parseInt('')NaN'dir. NaN yanlış olarak değerlendirilir, bu nedenle sonuç num0 olarak ayarlanır.

Ayrıca bu isNaN()işlevi kullanabilirsiniz :

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

Kimsenin kullanarak bahsetmiyorum görmek şaşırdı Number(). Verilmişse ondalık sayıları ayrıştıracağı kabul edilir, bu nedenle farklı bir şekilde hareket eder parseInt(), ancak zaten taban 10'u varsayar ve "" veya hatta "" değerini 0'a çevirir.

Kısıtlı olmayan kişiler için parseInt, bitwise OR işlecini (örtük ToInt32olarak işlenenlerini çağırır ) kullanabilirsiniz.

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

Not: ToInt32farklıdır parseInt. (yani parseInt('33Ab') === 33)

Sorun

Diğer cevaplar 0yanlış olanı dikkate almaz ve bu nedenle 0 yerine 20 olacaktır:

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

Çözüm

Sorunların çoğunu çözen bir yardımcı işlev öneriyorum:

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

Yardımcı işlevi aşağıdaki sonuçları verecektir:

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

Bence iş ayrıştırmaktan çok daha temiz mi, + işlecini kullan

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

Boş bir dize için ayrı bir denetim yapın (özel bir durum olduğu için) ve bu durumda sıfıra ayarlayın.

Başlangıca "0" yazabilir, ancak ardından ondalık sayı olduğunu ve sekizlik sayı olmadığını belirtmek için bir önek eklemeniz gerekir

Neden işlevi geçersiz kılmıyorsunuz? Bu durumda her zaman döndürür emin olabiliriz 0durumunda NaN:

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

Şimdi, kodunuzun herhangi bir yerinde:

parseInt('') === 0

Ben gibi basit dizeleri ile benzer bir sorun (firefox v34) vardı:

var myInt = parseInt("b4");

Bu yüzden hızlı bir kesmek geldi:

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

Ve sonra basit olmayan şeyler için şamandıralar + ints ile başa çıkmak için tüm aptalca karmaşıklaştı:

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

Gibi şeyler için 0 döndürecektir:

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

Bunu benim için, bir sayı için ve diğeri bir String için işlemek için 2 prototip oluşturdum.

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

Güvenlik kontrolünü kullanmak istemiyorsanız,

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

Örnek kullanım:

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

Açıklama, önemsiz bulamayanlar için:

Birbiriyle çarpıldığında, "örtük döküm" adı verilen bir yöntem, bilinmeyen tür işlenenini ilkel tür olan 'sayı'ya dönüştürmeye çalışır. Özellikle, boş bir dize 0 rakamı olur ve parseInt () için uygun bir tür olur ...

Yukarıda + işaretinin başına geçmesini öneren ve JavaScript'i Number örtülü dökümünü kullanmaya zorlayan PirateApp tarafından çok iyi bir örnek verildi.

Ayrıca bu şekilde, neden bir işlev yazmıyorsunuz ve gerektiğinde onu çağırmıyorsunuz. Hesaplamaları gerçekleştirmek için form alanlarına giriş olduğunu varsayıyorum.

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

bunu yapmanın nesi yanlış?

İşte kullanıyorum bir tryParseInt yöntemi, bu varsayılan değer ikinci parametre olarak alır, böylece ihtiyacınız olan her şey olabilir.

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

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

hala sayı tabanı kullanımına izin veren bir yardımcı işlev

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

Çok temiz bir kod olabilir, ben benzer sorunları vardı ve ben kullanarak çözüldü:

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

Bu çözümü arayan diğer insanlar için, sadece kullanın: ~~ parseInt olmadan, en temiz moddur.

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

NaN ise, bunun yerine 0 döndürür.

OBS. Bu çözüm yalnızca tamsayılar için geçerlidir