Vérifier si une variable contient une valeur numérique en Javascript?

En PHP, il est assez facile:

is_numeric(23);//true
is_numeric("23");//true
is_numeric(23.5);//true
is_numeric(true);//false

Mais comment je peux le faire en Javascript?
Je pourrais utiliser une expression régulière, mais est-il une fonction pour ça?

source d'informationauteur Vordreller | 2009-03-01

  1. 23

    Ce sujet: 

    function isNumber(n){
    return typeof(n) != "boolean" && !isNaN(n);
}

    La isNaN fonction intégrée est utilisée pour vérifier si une valeur est pas un certain nombre.

    Mise à jour: Christoph est à droite, en JavaScript les types Boolean sont convertibles en un Nombre, retour le 1 pour vrai et 0 pour faux, donc si vous évaluer 1 + true le résultat sera 2.

    Considérant ce problème j'ai mis à jour la fonction pour empêcher la conversion des valeurs booléennes à sa représentation numérique.

  2. 14

    Je ne pense pas que l'une des suggestions jusqu'à maintenant. Par exemple

    !isNaN(parseFloat(foo))

    n'est pas parce que parseFloat() ignore fuite des caractères non numériques.

    Pour contourner ce problème, vous pouvez comparer la valeur retournée à celui retourné par un casting via Number() (ou de manière équivalente en utilisant unaire +mais je préfère le cast explicite):

    parseFloat(foo) === Number(foo)

    Cela va encore fonctionner si les deux fonctions renvoient NaN parce que NaN !== NaN est true.

    Une autre possibilité serait d'abord jeté à la chaîne, puis le nombre et vérifiez ensuite NaNc'est à dire

    !isNaN(Number(String(foo)))

    ou, de manière équivalente, mais moins lisible (mais probablement plus rapide)

    !isNaN(+('' + foo))

    Si vous souhaitez exclure de l'infini de valeurs, utilisez isFinite() au lieu de !isNaN()c'est à dire

    isFinite(Number(String(foo)))

    Le cast explicite via Number() est en fait inutile, car isNan() et isFinite() cast nombre implicitement - c'est la raison pour laquelle !isNaN() ne fonctionne pas!

    À mon avis, la solution la plus appropriée serait donc

    isFinite(String(foo))

    Comme Matthieu l'a souligné, la deuxième approche ne permet pas de gérer les chaînes qui ne contiennent que des espaces correctement.

    Il n'est pas difficile à résoudre - utiliser le code de Matthieu commentaire ou

    isFinite(String(foo).trim() || NaN)

    Vous aurez à décider si c'est toujours plus agréable que de comparer les résultats de parseFloat() et Number().

  3. 5

    Vérification des types en javascript, vous pouvez utiliser le typeof opérateur:

    js> var x = 1;
js> typeof(x);
number

    Donc:

    if (typeof(x) === 'number') {
   //Do something
}

    Si vous voulez forcer la valeur d'une variable de nombre entier, vous pouvez utiliser parseInt(x, 10) qui va analyser la valeur d'un entier en base 10. De même, vous pouvez utiliser parseFloat si vous voulez une valeur à virgule flottante. Cependant, celles-ci ont toujours contraindre quel que soit le type de sorte de passage nulltrueetc retournera toujours un nombre. Toutefois, vous pouvez vérifier si ses un nombre valide en appelant isNaN.

    Afin de, mettre tous ensemble:

    !isNaN(parseFloat(23)) //true
!isNaN(parseFloat('23')) //true
!isNaN(parseFloat(23.5)) //true
!isNaN(parseFloat(true)) //false

    ou

    function isNumber(x) {
    return !isNaN(parseFloat(x));
}
  4. 3

    Cette vérification pour les valeurs numériques, y compris les négatifs et les nombres à virgule flottante.

    function is_numeric(val){
    return val && /^-?\d+(\.\d+)?$/.test(val + '');
}

    @Vordreller: j'ai corrigé les Regex. Il devrait fonctionner correctement maintenant.

  5. 1
    function is_numeric(val) {
  return ((+val) == val);
}

    Cela devrait faire l'affaire.

  6. 0

    Voici ce que je suis venu avec:

    value = "2.34";
if (parseFloat(value).toString() === value) {
    alert("number");
}

    Cela devrait fonctionner avec des flotteurs et des entiers, positifs et négatifs. Je ne sais pas à propos de l'infini, comme certaines des réponses ci-dessus ont discuté.

    Si votre valeur peut être un nombre et pas toujours une chaîne de caractères, vous pouvez modifier l' = = = = = et il va traiter les deux à la fois.

  7. 0

    Voici quelques repères pour isNaN vs isFinite et typeof === "nombre"

    http://jsperf.com/isnan-vs-isfinite-vs/3

    Apparemment typeof === "nombre" est environ 5 fois plus rapide