Question Existe-t-il une méthode (intégrée) en JavaScript pour vérifier si une chaîne est un nombre valide?


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


799
2017-10-06 19:12


origine


Réponses:


Pour vérifier si une variable (y compris une chaîne) est un nombre, vérifiez s'il ne s'agit pas d'un nombre:

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

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

Exemples

isNaN(123)         // false
isNaN('123')       // false
isNaN('1e10000')   // false (This translates to Infinity, which is a number)
isNaN('foo')       // true
isNaN('10px')      // true

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

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

Pour convertir une chaîne contenant un nombre en un nombre:

ne fonctionne que si la chaîne seulement contient des caractères numériques, sinon il retourne 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 librement en un nombre

utile pour convertir '12px' en 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 à +num, parseInt (comme son nom l'indique) convertira un float en un nombre entier en coupant tout ce qui suit le point décimal (si vous voulez utiliser parseInt()  en raison de ce comportement, vous êtes probablement mieux d'utiliser une autre méthode à la place):

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

Chaînes vides

Les chaînes vides peuvent être un peu contre-intuitives. +num convertit les chaînes vides à zéro, et isNaN() suppose la même chose:

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

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

parseInt('')       // NaN

1667
2017-10-06 19:24



Et vous pourriez aller à la RegExp-way:

var num = "987238";

if(num.match(/^-{0,1}\d+$/)){
  //valid integer (positive or negative)
}else if(num.match(/^\d+\.\d+$/)){
  //valid float
}else{
  //not valid number
}

35
2017-10-06 19:20



Essaie le Fonction isNan:

La fonction isNaN () détermine si une valeur est un nombre illégal (Not-a-Number).

Cette fonction renvoie true si la valeur est égale à NaN. Sinon, il renvoie false.

Cette fonction est différente du numéro spécifique Number.isNaN () méthode.

La fonction globale isNaN () convertit la valeur testée en nombre, puis la teste.

Number.isNan () ne convertit pas les valeurs en nombre, et ne retournera pas true pour toute valeur qui n'est pas du type Number ...


21
2017-10-06 19:14



Si vous voulez vraiment vous assurer qu'une chaîne contient seulement un nombre, un nombre (entier ou flottant), et exactement un nombre, vous ne peux pas utilisation parseInt()/ parseFloat(), Number(), ou !isNaN() par eux-mêmes. Notez que !isNaN() est en train de revenir true quand Number() retournerait un nombre, et false quand il reviendrait NaN, donc je vais l'exclure du reste de la discussion.

Le problème avec parseFloat() est qu'il retournera un nombre si la chaîne contient un nombre, même si la chaîne ne contient pas seulement et exactement un numéro:

parseFloat("2016-12-31")  // returns 2016
parseFloat("1-1") // return 1
parseFloat("1.2.3") // returns 1.2

Le problème avec Number() est qu'il retournera un nombre dans les cas où la valeur passée n'est pas un nombre du tout!

Number("") // returns 0
Number(" ") // returns 0
Number(" \u00A0   \t\n\r") // returns 0

Le problème avec le roulement de votre propre regex est que si vous ne créez pas la regex exacte pour faire correspondre un nombre à virgule flottante comme Javascript le reconnaît, vous allez manquer des cas ou reconnaître des cas où vous ne devriez pas. Et même si vous pouvez rouler votre propre regex, pourquoi? Il y a des façons intégrées plus simples de le faire.

Cependant, il s'avère que Number() (et isNaN()) fait la bonne chose pour chaque cas où parseFloat()renvoie un nombre quand il ne devrait pas, et vice versa. Donc, pour savoir si une chaîne est vraiment exactement et seulement un nombre, appelez les deux fonctions et voir si elles tous les deux retourner vrai:

function isNumber(str) {
  if (typeof str != "string") return false // we only process strings!
  // could also coerce to string: str = ""+str
  return !isNaN(str) && !isNaN(parseFloat(str))
}

20
2018-03-02 22:56



Si vous essayez juste de vérifier si une chaîne est un nombre entier (pas de décimales), regex est un bon moyen d'y aller. D'autres méthodes telles que isNaN sont trop compliqués pour quelque chose de si simple.

function isNumeric(value) {
    return /^-{0,1}\d+$/.test(value);
}

console.log(isNumeric('abcd'));         // false
console.log(isNumeric('123a'));         // false
console.log(isNumeric('1'));            // true
console.log(isNumeric('1234567890'));   // true
console.log(isNumeric('-23'));          // true
console.log(isNumeric(1234));           // true
console.log(isNumeric('123.4'));        // false
console.log(isNumeric(''));             // false
console.log(isNumeric(undefined));      // false
console.log(isNumeric(null));           // false

Permettre seulement positif les nombres entiers utilisent ceci:

function isNumeric(value) {
    return /^\d+$/.test(value);
}

console.log(isNumeric('123'));          // true
console.log(isNumeric('-23'));          // false

17
2018-06-27 17:13



Ancienne question, mais il manque plusieurs points dans les réponses données.

Notation scientifique.

!isNaN('1e+30') est trueCependant, dans la plupart des cas où les gens demandent des chiffres, ils ne veulent pas faire correspondre des choses comme 1e+30.

Les grands nombres flottants peuvent se comporter bizarrement

Observez (en utilisant 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
>

D'autre part:

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

Donc, si l'on s'attend String(Number(s)) === s, alors mieux vaut limiter vos chaînes à 15 chiffres au maximum (après avoir omis les zéros en tête).

Infini

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

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

  • notation non scientifique
  • conversion prévisible en Number et de retour à String
  • fini

Ce 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 complet. Les zéros en tête ne sont pas traités ici, mais ils testent le test de longueur.


10
2017-10-02 11:28



parseInt (), mais sachez que cette fonction est un peu différente dans le sens où elle renvoie par exemple 100 pour parseInt ("100px").


5
2017-10-06 19:16



Vous pouvez utiliser le résultat de Nombre lors du passage d'un argument à son constructeur.

Si l'argument (une chaîne) ne peut pas être converti en un nombre, il renvoie NaN, vous pouvez donc déterminer si la chaîne fournie est un nombre valide ou non.

Notes: Note lors du passage de la chaîne vide ou '\t\t' et '\n\t' comme nombre renverra 0; Passant true retournera 1 et false renvoie 0.

    Number('34.00') // 34
    Number('-34') // -34
    Number('123e5') // 12300000
    Number('123e-5') // 0.00123
    Number('999999999999') // 999999999999
    Number('9999999999999999') // 10000000000000000 (integer accuracy up to 15 digit)
    Number('0xFF') // 255
    Number('Infinity') // Infinity  

    Number('34px') // NaN
    Number('xyz') // NaN
    Number('true') // NaN
    Number('false') // NaN

    // cavets
    Number('    ') // 0
    Number('\t\t') // 0
    Number('\n\t') // 0

5
2018-03-13 09:31