Jak zmienić NaN z parseInt na 0 dla pustego ciągu?

Czy możliwe jest jakoś zwrócić 0 zamiast NaNpodczas analizowania wartości w JavaScript?

W przypadku pustego ciągu parseIntzwraca NaN.

Czy w JavaScript można zrobić coś takiego NaN?

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

A może istnieje inna funkcja lub wtyczka jQuery, która może zrobić coś podobnego?

var s = '';

var num = parseInt(s) || 0;

Gdy nie jest używany z wartościami logicznymi, ||operator logiczny OR ( ) zwraca pierwsze wyrażenie ( parseInt(s)), jeśli można je oszacować jako prawda, w przeciwnym razie zwraca drugie wyrażenie (0). Zwracana wartość parseInt('')to NaN. NaN ocenia się na false, więc numostatecznie zostaje ustawiony na 0.

Możesz także użyć isNaN()funkcji:

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

Byłem zaskoczony, gdy nikt nie wspomniał o używaniu Number(). To prawda, że ​​parsuje ułamki dziesiętne, jeśli są podane, więc będzie działał inaczej niż parseInt(), jednak już zakłada podstawową 10 i zmieni „” lub nawet „” na 0.

Dla osób, które nie są ograniczone parseInt, możesz użyć bitowego operatora OR (który domyślnie wywołuje ToInt32jego operandy).

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

Uwaga: ToInt32różni się od parseInt. (tj. parseInt('33Ab') === 33)

Problem

Inne odpowiedzi nie biorą pod uwagę, że 0jest to fałsz, a zatem następujące będą wynosić 20 zamiast 0:

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

Rozwiązanie

Proponuję funkcję pomocnika, która rozwiązuje większość problemów:

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

Funkcja pomocnika da następujące wyniki:

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

Czy praca jest dużo czystsza niż parsowanie Moim zdaniem użyj operatora +

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

Wykonaj osobne sprawdzenie pustego łańcucha (ponieważ jest to jeden konkretny przypadek) i w tym przypadku ustaw go na zero.

Możesz poprosić „0” na początek, ale musisz dodać przedrostek, aby wskazać, że jest to liczba dziesiętna, a nie ósemkowa

Dlaczego nie zastąpić funkcji? W takim przypadku zawsze możesz mieć pewność, że zwróci 0w przypadku NaN:

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

Teraz w dowolnym miejscu kodu:

parseInt('') === 0

Miałem podobny problem (Firefox V34) z prostymi ciągami, takimi jak:

var myInt = parseInt("b4");

Więc wymyśliłem szybki hack:

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

A potem wszystko głupio skomplikowało zajmowanie się floatami + intami dla nie-prostych rzeczy:

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

Zwróci 0 za rzeczy takie jak:

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

Stworzyłem 2 prototyp, aby sobie z tym poradzić, jeden dla liczby, a drugi dla ciągu.

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

Jeśli nie chcesz korzystać z kontroli bezpieczeństwa, użyj

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

Przykładowe użycie:

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

Wyjaśnienie dla tych, którzy nie uważają tego za trywialne:

Mnożenie przez jeden, metoda nazywana „rzutowaniem niejawnym”, próbuje przekształcić operand nieznanego typu w pierwotny typ „liczba”. W szczególności pusty ciąg stałby się liczbą 0, co czyni go odpowiednim typem dla parseInt () ...

Bardzo dobry przykład podał także powyżej PirateApp, który zasugerował, aby wstawić znak +, zmuszając JavaScript do użycia rzutowania niejawnego Number.

Również w ten sposób, dlaczego nie napisać funkcji i wywołać ją tam, gdzie jest to wymagane. Zakładam, że jest to wpis w polach formularza w celu wykonania obliczeń.

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

co jest nie tak robiąc?

Oto metoda tryParseInt, której używam, która przyjmuje wartość domyślną jako drugi parametr, dzięki czemu może być wszystkim, czego potrzebujesz.

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

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

funkcja pomocnicza, która nadal pozwala na korzystanie z podstawki

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

Możesz mieć bardzo czysty kod, miałem podobne problemy i rozwiązałem go za pomocą:

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

Dla innych osób szukających tego rozwiązania wystarczy użyć: ~~ bez analizy, jest to najczystszy tryb.

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

Jeśli NaN, zwróci 0 zamiast tego.

OBS. To rozwiązanie dotyczy tylko liczb całkowitych