Est-il possible (intégré) en JavaScript pour vérifier si une chaîne est un numéro valide ?

Question

J’espère qu’il y a quelque chose dans le même espace conceptuel que l’ancienne fonction de VB6 IsNumeric() ?

Answer 1

Pour vérifier si une variable n'est pas un nombre:

Cela fonctionne indépendamment du fait que la variable contient une chaîne de caractères ou un nombre.

isNaN(num)     // returns true if the variable does NOT contain a valid number

Exemples:

isNaN(123)     // false
isNaN('123')   // false
isNaN('foo')   // true
isNaN('10px')  // true

Bien sûr, vous pouvez annuler si vous avez besoin de. Par exemple, pour mettre en œuvre l' IsNumeric exemple que vous avez donné:

function isNumeric(num){
    return !isNaN(num)
}

Pour convertir une chaîne de caractères contenant un nombre en nombre:

ne fonctionne que si la chaîne de seulement contient des caractères numériques, sinon elle renvoie NaN.

+num              // returns the numeric value of the string, or NaN if the 
                  // string isn't purely numeric characters

Exemples:

+'12'             // 12
+'12.'            // 12
+'12..'           // Nan
+'.12'            // 0.12
+'..12'           // Nan
+'foo'            // NaN
+'12px'           // NaN

Pour convertir une chaîne vaguement à un certain nombre

utile pour la conversion de '12px' à 12, par exemple.

parseInt(num)     // extracts a numeric value from the 
                  // start of the string, or NaN.

Exemples:

parseInt('12')    // 12
parseInt('aaa')   // NaN
parseInt('12px')  // 12
parseInt('foo2')  // NaN      These last two may be different
parseInt('12a5')  // 12       from what you expected to see. 

Flotteurs

Gardez à l'esprit que, contrairement aux +num, parseInt (comme son nom l'indique) vous permet de convertir un float en un entier par hacher le tout après le point décimal (si vous souhaitez utiliser parseInt() en raison de ce comportement, vous êtes probablement mieux avec Math.floor() plutôt):

parseInt(12.345)   // 12
parseInt('12.345') // 12
+'12.345'          // 12.345

Les cordes à vide

Les cordes à vide peut-être un peu contre-intuitif. +num convertit les cordes à vide à zéro, et isNaN() assume la même chose:

+''                // 0
isNaN('')          // false

Mais parseInt() n'est pas d'accord:

parseInt('')       // NaN

Answer 2

Si vous essayez seulement de vérifier si une chaîne est un nombre entier (sans décimale), regex est une bonne façon de faire. Autres méthodes telles que `` sont trop compliquées pour quelque chose de si simple.

Answer 3

Et vous pouvez aller le RegExp-way :

Answer 4

Essayez la fonction isNan...

http://www.w3schools.com/jsref/jsref_isNaN.asp

Answer 5

Vieille question, mais il y a plusieurs points manquants dans les réponses données.

La notation scientifique.

!isNaN('1e+30') est true, mais dans la plupart des cas, quand les gens demandent pour les chiffres, ils ne veulent pas correspondre à des choses comme l' 1e+30.

De grands nombres flottants peut avoir un comportement bizarre

Observer (à l'aide de Node.js):

> var s = Array(16 + 1).join('9')
undefined
> s.length
16
> s
'9999999999999999'
> !isNaN(s)
true
> Number(s)
10000000000000000
> String(Number(s)) === s
false
>

Sur l'autre main:

> var s = Array(16 + 1).join('1')
undefined
> String(Number(s)) === s
true
> var s = Array(15 + 1).join('9')
undefined
> String(Number(s)) === s
true
>

Ainsi, si l'on s'attend à ce String(Number(s)) === s, alors préférable de limiter vos chaînes à 15 chiffres au maximum (après avoir sauté les zéros non significatifs).

L'infini

> typeof Infinity
'number'
> !isNaN('Infinity')
true
> isFinite('Infinity')
false
>

Compte tenu de tout cela, vérifier que la chaîne est un nombre satisfaisant toutes les conditions suivantes:

• non la notation scientifique
• prévisible conversion en Number et retour à l' String
• finis

n'est pas une tâche facile. Voici une version simple:

  function isNonScientificNumberString(o) {
    if (!o || typeof o !== 'string') {
      // Should not be given anything but strings.
      return false;
    }
    return o.length <= 15 && o.indexOf('e+') < 0 && o.indexOf('E+') < 0 && !isNaN(o) && isFinite(o);
  }

Cependant, même celui-ci est loin d'être complète. Les zéros non significatifs ne sont pas traitées ici, mais ils ne la vis de la longueur de test.