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

Vous pouvez également utiliser la fonction isNaN():

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

J'ai été surpris de ne voir personne mentionner l'utilisation de Number(). Certes, il analysera les décimales si elles sont fournies, donc agira différemment de parseInt(), mais il suppose déjà la base 10 et tournera ""ou même "" à 0.

Pour les personnes qui ne sont pas restreint à parseInt, vous pouvez utiliser l'opérateur or (qui appelle implicitement ToInt32 à ses 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: ToInt32 est différent de parseInt. (c'est-à-dire parseInt('33Ab') === 33)

Le problème

Les autres réponses ne tiennent pas compte du fait que 0 est faux, et donc ce qui suit sera 20 au lieu de 0:

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

La solution

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

function getNumber(number, defaultNumber) {
    return isNaN(parseInt(number, 10)) ? defaultNumber : parseInt(number, 10);
}

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

getNumber('0', 20); // 0
getNumber('2', 20); // 2
getNumber('2.2', 20); // 2
getNumber('any string', 20); // 20
getNumber(undefined, 20); // 20
getNumber(null, 20); // 20
getNumber(NaN, 20); // 20
getNumber(false, 20); // 20
getNumber(true, 20); // 20

var value = isNaN(parseInt(tbb)) ? 0 : parseInt(tbb);

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

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

Pourquoi ne pas remplacer la fonction? Dans ce cas, vous pouvez toujours être sûr qu'il retourne 0 dans le 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");

Donc je suis venu avec un hack rapide de:

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

Et puis est devenu tout stupide compliqué pour faire face à des flotteurs + ints 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 retournera 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

Le travail est-il beaucoup plus propre que parseInt à 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

// implicit cast
var value = parseInt(tbb*1); // see original question

Explication, pour ceux qui ne le trouvent pas trivial:

Multipliant par un, une méthode appelée "cast implicite", tente de transformer l'opérande de type inconnu en type primitif 'number'. En particulier, une chaîne vide deviendrait le nombre 0, ce qui en fait 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 le nombre implicite cast.

Aussi de cette façon, pourquoi ne pas écrire une fonction et l'appeler si nécessaire . Je suppose que c'est l'entrée dans les champs de 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); 

Quel est le problème en faisant ça?

Voici une méthode tryParseInt que j'utilise, cela prend la valeur par défaut comme deuxième paramètre afin qu'il 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

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 voulez pas utiliser le contrôle de sécurité, utiliser

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

Une fonction d'aide qui permet toujours d'utiliser la base

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