web-dev-qa-db-fra.com

Comment transformer NaN de parseInt en chaîne vide?

Est-il possible en quelque sorte de renvoyer 0 au lieu de NaN lors de l'analyse de valeurs en JavaScript?

Dans le cas d'une chaîne vide, parseInt renvoie 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?

javascriptnan
244
Joper
var s = '';

var num = parseInt(s) || 0;
645
Matthew Caruana Galizia

Vous pouvez également utiliser la fonction isNaN():

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

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

20
Chris Werner

Pour les personnes qui ne sont pas limitées à parseInt, vous pouvez utiliser l'opérateur bitwise 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)

7
Ahmad Ibrahim

Le problème

Les autres réponses ne tiennent pas compte du fait que 0 est une fausseté et que, par conséquent, ce qui suit sera 20 au lieu de 0:

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

La solution

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

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

La fonction d'assistance 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
4
sqren
var value = isNaN(parseInt(tbb)) ? 0 : parseInt(tbb);
2
Milap Jethwa

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
1
PirateApp

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

var myInt = parseInt("b4");

Alors je suis venu avec un rapide piratage de:

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

Et puis tout compliqué à traiter avec des floats + 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
1
bob

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

Vous pouvez apposer et "0" au début, mais vous devez alors ajouter un préfixe pour indiquer qu'il s'agit d'une décimale et non d'un nombre octal

1
Schroedingers Cat
//////////////////////////////////////////////////////
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
1
AbdulRahman AlShamiri
// implicit cast
var value = parseInt(tbb*1); // see original question

Explication, pour ceux qui ne le trouvent pas trivial:

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

PirateApp a également donné un très bon exemple. Il a suggéré d'ajouter le signe + avant, obligeant JavaScript à utiliser la conversion implicite Number.

1
Fabien Haddadi

Pourquoi ne pas remplacer la fonction? Dans ce cas, vous pouvez toujours être sûr qu'il renvoie 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
1
pimvdb

Aussi, pourquoi ne pas écrire une fonction et l'appeler si nécessaire. 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 faire ça?

0
Naresh

une fonction d'aide qui permet encore d'utiliser la base

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

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

var a="bcd";
~~parseInt(a);
0
Bishal Gautam

Voici une méthode tryParseInt que j’utilise, elle prend la valeur par défaut comme second paramètre afin que vous puissiez disposer de 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
0
Darrelk

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é, 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
0
Mike