Comment transformer NaN de parseInt en 0 pour une chaîne vide?

Est-il possible de retourner 0 au lieu de NaNlors de l'analyse des valeurs en JavaScript?

En cas de parseIntretour de la chaîne vide NaN.

Est-il possible de faire quelque chose comme ça en JavaScript pour vérifier NaN?

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

Ou peut-être existe-t-il une autre fonction ou un plugin jQuery qui peut faire quelque chose de similaire?

var s = '';

var num = parseInt(s) || 0;

Lorsqu'il n'est pas utilisé avec des valeurs booléennes, l' ||opérateur logique OR ( ) renvoie la première expression ( parseInt(s)) si elle peut être évaluée à true, sinon il renvoie la deuxième expression (0). La valeur de retour de parseInt('')est NaN. NaN est évalué à faux, donc numfinit par être mis à 0.

Vous pouvez également utiliser la isNaN()fonction:

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

J'ai été surpris de ne voir personne mentionner l'utilisation Number(). Certes, il analysera les décimales s'il est fourni, il agira donc différemment de parseInt(), cependant il suppose déjà la base 10 et transformera "" ou même "" en 0.

Pour les personnes qui ne sont pas limitées à parseInt, vous pouvez utiliser l'opérateur OR au niveau du bit (qui appelle implicitement ToInt32ses opérandes).

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

Remarque: ToInt32est différent de parseInt. (ie parseInt('33Ab') === 33)

Le problème

Les autres réponses ne prennent pas en compte ce qui 0est faux, et donc les suivantes seront 20 au lieu de 0:

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

La solution

Je propose une fonction d'aide, qui résout la plupart des problèmes:

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

La fonction d'assistance donnera les résultats suivants:

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

Est-ce que le travail est beaucoup plus propre que l'analyse à mon avis, utilisez l'opérateur +

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

Effectuez une vérification distincte pour une chaîne vide (car il s'agit d'un cas spécifique) et définissez-la sur zéro dans ce cas.

Vous pouvez appeand "0" au début, mais vous devez ensuite ajouter un préfixe pour indiquer qu'il s'agit d'un nombre décimal et non octal

Pourquoi ne pas remplacer la fonction? Dans ce cas, vous pouvez toujours être sûr qu'il revient 0en cas de NaN:

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

Maintenant, n'importe où dans votre code:

parseInt('') === 0

J'ai eu un problème similaire (firefox v34) avec des chaînes simples comme:

var myInt = parseInt("b4");

J'ai donc trouvé un hack rapide de:

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

Et puis tout est devenu stupide et compliqué de gérer les flotteurs + les pouces pour des choses non simples:

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

Il renverra 0 pour des choses comme:

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

J'ai créé un prototype 2 pour gérer cela pour moi, un pour un nombre et un pour une chaîne.

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

Si vous ne souhaitez pas utiliser le contrôle de sécurité, utilisez

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

Exemple d'utilisation:

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

Explication, pour ceux qui ne trouvent pas cela trivial:

La multiplication par un, une méthode appelée «distribution implicite», tente de transformer l'opérande de type inconnu en «nombre» de type primitif. En particulier, une chaîne vide deviendrait numéro 0, ce qui en ferait un type éligible pour parseInt () ...

Un très bon exemple a également été donné ci-dessus par PirateApp, qui a suggéré d'ajouter le signe +, forçant JavaScript à utiliser la distribution implicite de Number.

De cette façon, pourquoi ne pas écrire une fonction et l'appeler là où vous en avez besoin. Je suppose que c'est l'entrée dans les champs du formulaire pour effectuer des calculs.

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

qu'est-ce qui ne va pas?

Voici une méthode tryParseInt que j'utilise, elle prend la valeur par défaut comme deuxième paramètre afin qu'elle puisse être tout ce dont vous avez besoin.

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

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

une fonction d'aide qui permet toujours d'utiliser le radix

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

Vous pouvez avoir du code très propre, j'ai eu des problèmes similaires et je l'ai résolu en utilisant:

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

Pour les autres personnes à la recherche de cette solution, utilisez simplement: ~~ sans parseInt, c'est le mode le plus propre.

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

Si NaN, il renverra 0 à la place.

OBS. Cette solution s'applique uniquement aux entiers