Wie verwandle ich NaN von parseInt in 0 für eine leere Zeichenfolge?

Ist es möglich, 0 zurückzugeben, anstatt NaNWerte in JavaScript zu analysieren?

Im Falle der leeren Zeichenfolge wird parseIntzurückgegeben NaN.

Ist es möglich, so etwas in JavaScript zu überprüfen NaN?

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

Oder gibt es vielleicht eine andere Funktion oder ein anderes jQuery-Plugin, das etwas Ähnliches tun kann?

var s = '';

var num = parseInt(s) || 0;

Wenn der ||Operator logisch ODER ( ) nicht mit booleschen Werten verwendet wird, gibt er den ersten Ausdruck ( parseInt(s)) zurück, wenn er als wahr ausgewertet werden kann, andernfalls gibt er den zweiten Ausdruck (0) zurück. Der Rückgabewert von parseInt('')ist NaN. NaN wird als falsch ausgewertet und numam Ende auf 0 gesetzt.

Sie können auch die isNaN()Funktion verwenden:

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

Ich war überrascht, dass niemand die Verwendung erwähnte Number(). Zugegeben, es analysiert Dezimalstellen, wenn dies vorgesehen ist, verhält sich also anders als parseInt(), nimmt jedoch bereits die Basis 10 an und wandelt "" oder sogar "" in 0 um.

Für Personen, die nicht darauf beschränkt sind parseInt, können Sie den bitweisen ODER-Operator verwenden (der implizit ToInt32seine Operanden aufruft ).

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

Hinweis: ToInt32unterscheidet sich von parseInt. (dh parseInt('33Ab') === 33)

Das Problem

Andere Antworten berücksichtigen nicht, dass dies 0falsch ist, und daher lautet das Folgende 20 anstelle von 0:

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

Die Lösung

Ich schlage eine Hilfsfunktion vor, die die meisten Probleme löst:

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

Die Hilfsfunktion liefert folgende Ergebnisse:

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

Ist der Job meiner Meinung nach viel sauberer als parseInt? Verwenden Sie den 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);

Führen Sie eine separate Prüfung für eine leere Zeichenfolge durch (da es sich um einen bestimmten Fall handelt) und setzen Sie sie in diesem Fall auf Null.

Sie könnten am Anfang "0" eingeben, aber dann müssen Sie ein Präfix hinzufügen, um anzuzeigen, dass es sich um eine Dezimalzahl und nicht um eine Oktalzahl handelt

Warum nicht die Funktion überschreiben? In diesem Fall können Sie immer sicher sein, dass es zurückkehrt, 0wenn NaN:

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

Jetzt überall in Ihrem Code:

parseInt('') === 0

Ich hatte ein ähnliches Problem (Firefox v34) mit einfachen Zeichenfolgen wie:

var myInt = parseInt("b4");

Also kam ich auf einen kurzen Hack von:

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

Und dann wurde alles dumm kompliziert, mit Floats + Ints für nicht einfache Sachen umzugehen:

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

Es wird 0 zurückgeben für Dinge wie:

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

Ich habe einen 2-Prototyp erstellt, um dies für mich zu erledigen, einen für eine Zahl und einen für einen 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);
});

Wenn Sie den Sicherheitscheck nicht verwenden möchten, verwenden Sie

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

Anwendungsbeispiel:

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

Erklärung für diejenigen, die es nicht trivial finden:

Durch Multiplizieren mit eins, einer Methode namens "implizite Umwandlung", wird versucht, den Operanden vom unbekannten Typ in den primitiven Typ 'number' umzuwandeln. Insbesondere würde eine leere Zeichenfolge die Nummer 0 werden, was sie zu einem geeigneten Typ für parseInt () ... macht.

Ein sehr gutes Beispiel wurde oben auch von PirateApp gegeben, der vorschlug, das + -Zeichen voranzustellen, wodurch JavaScript gezwungen wurde, die implizite Umwandlung von Number zu verwenden.

Schreiben Sie auch auf diese Weise eine Funktion und rufen Sie sie auf, wo immer dies erforderlich ist. Ich gehe davon aus, dass dies der Eintrag in die Formularfelder ist, um Berechnungen durchzuführen.

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

Was ist falsch daran?

Hier ist eine tryParseInt-Methode, die ich verwende. Dabei wird der Standardwert als zweiter Parameter verwendet, sodass alles sein kann, was Sie benötigen.

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

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

eine Hilfsfunktion, mit der der Radix weiterhin verwendet werden kann

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

Sie können sehr sauberen Code haben, ich hatte ähnliche Probleme und ich löste es mit:

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

Für andere Leute, die nach dieser Lösung suchen, verwenden Sie einfach: ~~ ohne parseInt, es ist der sauberste Modus.

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

Wenn NaN, wird stattdessen 0 zurückgegeben.

OBS. Diese Lösung gilt nur für ganze Zahlen