(Intégré) façon JavaScript pour vérifier si une chaîne est un nombre valide


1191

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


3
Voir cette question connexe , que j'ai posée il y a quelque temps.
Michael Haren

38
Si vous allez à cette question, essayez de sauter toutes les réponses RegEx. Ce n'est PAS la façon de procéder.
Joel Coehoorn

14
A moins que l'on ne veuille faire exactement cela: vérifier si une chaîne donnée a le format d'un flux de chiffres valide. Pourquoi cela devrait-il être faux alors?
SasQ

17
La réponse sélectionnée est incorrecte !!! Voir ses commentaires, mais au fond il échoue avec , par exemple isNaN(""), isNaN(" "), isNaN(false), etc. renvoie falsepour ces derniers , ce qui implique qu'ils sont des nombres.
Andrew

1
donc la réponse sélectionnée est incorrecte, l'expression rationnelle n'est pas la façon de le faire non plus. Laquelle est correcte alors?
vir us

Réponses:


2322

Pour vérifier si une variable (y compris une chaîne) est un nombre, vérifiez si ce n'est pas un nombre:

Cela fonctionne indépendamment du fait que le contenu variable soit 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 cela si vous en avez besoin. Par exemple, pour implémenter l' IsNumericexemple que vous avez donné:

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

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

Fonctionne uniquement si la chaîne ne contient que des caractères numériques, sinon elle 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 de manière lâche 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) vous permet de convertir un flotteur en un entier en coupant tout ce qui suit le point décimal (si vous souhaitez utiliser en parseInt() 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. +numconvertit les chaînes vides ou les chaînes avec des espaces à zéro et isNaN()suppose la même chose:

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

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

parseInt('')       // NaN
parseInt('   ')    // NaN

133
Une remarque très importante à propos de parseInt est qu'elle vous permettra de spécifier un radix pour convertir la chaîne en int. C'est un gros problème car il essaie de deviner un radix pour vous si vous ne le fournissez pas. Ainsi, par exemple: parseInt ("17") donne 17 (décimal, 10), mais parseInt ("08") donne 0 (octal, 8). Donc, sauf si vous en avez l'intention autrement, il est plus sûr d'utiliser parseInt (nombre, 10), en spécifiant explicitement 10 comme radix.
Adam Raney

36
Notez que! IsNaN (non défini) renvoie false.
David Hellsing

111
C'est tout simplement faux - comment at-il obtenu autant de votes positifs? Vous ne pouvez pas utiliser isNaN"Pour vérifier si une variable n'est pas un nombre". "not a number" n'est pas la même chose que "IEEE-794 NaN", qui est ce qui isNaNteste. En particulier, cette utilisation échoue lors du test des booléens et des chaînes vides, au moins. Voir developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… .
EML

46
Le moyen le plus rapide de vérifier si quelque chose est un nombre est la vérification «égal à soi»: var n = 'a'; if (+n === +n) { // is number }il est ~ 3994% plus rapide que isNaN dans la dernière version de Chrome. Voir le test de performance ici: jsperf.com/isnan-vs-typeof/5
Kevin Jurkowski

22
** Avertissement ** Cette réponse est fausse. À utiliser à vos risques et périls. Exemple:isNaN(1 + false + parseInt("1.do you trust your users?"))
keithpjolley

55

Et vous pouvez utiliser la méthode RegExp:

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
}

40
Dans ce cas, RegExp == mauvais
Joel Coehoorn

10
Cela échoue sur les nombres hexadécimaux (0x12, par exemple), flotte sans zéro non significatif (.42, par exemple) et nombres négatifs.
Ori

17
@JoelCoehoorn Soin d'expliquer pourquoi RegExp == est mauvais ici? Semble être un cas d'utilisation valable pour moi.
computrius

6
Il y a plus de façons qu'il n'y paraît de construire un nombre (les nombres hexadécimaux dans un autre commentaire ne sont qu'un exemple), et il y a beaucoup de nombres qui peuvent ne pas être considérés comme valides (débordement du type, trop précis, etc.). En outre, l'expression régulière est à la fois plus lente et plus compliquée que l'utilisation des mécanismes intégrés
Joel Coehoorn

1
devrait également correspondre à la notation scientifique ... 1e10 etc.
Joseph Merdrignac

51

Si vous essayez simplement de vérifier si une chaîne est un nombre entier (pas de décimales), l'expression régulière est une bonne façon de procéder. D'autres méthodes telles que isNaNtrop compliquées pour quelque chose d'aussi 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

Pour autoriser uniquement les nombres entiers positifs , utilisez ceci:

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

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

11
console.log (isNumeric ('- 1'));
yongnan

5
console.log (isNumeric ('2e2'));
Gaël Barbin

11
Peut-être juste renommer "isNumeric" en "hasOnlyDigits". dans de nombreux cas, c'est exactement le chèque que vous recherchez.
gus3001

1
C'est ce que je cherchais, l'équivalent de php ctype_digit
Miguel Pynto

/^-?\d+$/droite?
Sukima

36

Si vous voulez vraiment vous assurer qu'une chaîne ne contient qu'un nombre, un nombre (entier ou à virgule flottante), et exactement un numéro, vous ne pouvez pas utiliser parseInt()/ parseFloat(), Number()ou !isNaN()par eux - mêmes. Notez que !isNaN()revient réellement truequand Number()retournerait un nombre, et falsequand il retourneraitNaN , donc je l'exclurai du reste de la discussion.

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

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

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

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

Le problème avec le roulement de votre propre expression régulière est que, sauf si vous créez l'expression exacte exacte pour correspondre à un nombre à virgule flottante car 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 existe des moyens intégrés 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 alors qu'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 voyez si elles retournent toutes les deux 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))
}

2
Cela renvoie vrai lorsque la chaîne a des espaces de début ou de fin. ' 1', '2 'Et ' 3 'tout retour vrai.
Rudey

Ajouter quelque chose comme ça à l'instruction return résoudrait cela: &&! / ^ \ S + | \ s + $ / g.test (str)
Ultroman the Tacoman

2
@RuudLenders - la plupart des gens ne se soucient pas s'il y a des espaces de fin qui sont supprimés pour faire de la chaîne un nombre valide, car il est facile de placer accidentellement les espaces supplémentaires dans de nombreuses interfaces.
Ian

3
C'est vrai au cas où la chaîne de chiffres proviendrait d'une entrée utilisateur. Mais je pensais que je devrais quand même mentionner les espaces, car je pense que la plupart des gens qui ont besoin d'une isNumberfonction ne s'occupent pas des interfaces utilisateur. De plus, une bonne entrée de nombre ne permettra pas de commencer par les espaces.
Rudey

36

La réponse acceptée pour cette question a quelques défauts (comme l'ont souligné quelques autres utilisateurs). C'est l'un des moyens les plus simples et éprouvés de l'aborder en javascript:

function isNumeric(n) {
  return !isNaN(parseFloat(n)) && isFinite(n);
}

Voici quelques bons cas de test:

console.log(isNumeric(12345678912345678912)); // true
console.log(isNumeric('2 '));                 // true
console.log(isNumeric('-32.2 '));             // true
console.log(isNumeric(-32.2));                // true
console.log(isNumeric(undefined));            // false

// the accepted answer fails at these tests:
console.log(isNumeric(''));                   // false
console.log(isNumeric(null));                 // false
console.log(isNumeric([]));                   // false

22

Essayez la 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, elle renvoie faux.

Cette fonction est différente de la méthode Number.isNaN () spécifique à Number .

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

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


2
Assurez-vous d'ajouter une vérification pour la chaîne vide. isNaN ('') renvoie false mais vous voulez probablement qu'il renvoie true dans ce cas.
Michael Haren

3
isFinite est une meilleure vérification - il s'agit du cas de coin étrange d'Infinity
JonnyRaa

3
@MichaelHaren Pas assez bon! isNaN()renvoie falsepour TOUTE chaîne contenant uniquement des caractères d'espacement, y compris des éléments comme '\ u00A0'.
Michael

1
AVERTISSEMENT: ne fonctionne pas pour les valeurs: null, "" (chaîne vide) et false.
Jenny O'Reilly

Je me rends compte que cette réponse a été donnée il y a 11 ans et quelques minutes avant celle acceptée, mais que cela vous plaise ou non, la réponse acceptée a BEAUCOUP plus de conversation autour d'elle, donc cette réponse n'ajoute vraiment rien à la réponse à la question. Je suggérerais de le supprimer pour éviter de distraire les nouveaux lecteurs. Je pense aussi que vous obtiendrez l'insigne Discipline si vous le faites.
Dan Dascalescu

14

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

Notation scientifique.

!isNaN('1e+30')est true, cependant, dans la plupart des cas, lorsque les gens demandent des chiffres, ils ne veulent pas faire correspondre des choses comme1e+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 attend String(Number(s)) === s , mieux vaut limiter vos chaînes à 15 chiffres au maximum (après avoir omis les zéros de 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 retour àString
  • fini

n'est pas une tâche si 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 terminé. Les zéros non significatifs ne sont pas traités ici, mais ils vissent le test de longueur.


1
"mais dans la plupart des cas, lorsque les gens demandent des chiffres, ils ne veulent pas faire correspondre des choses comme 1e + 30" Pourquoi diriez-vous cela? Si quelqu'un veut savoir si une chaîne contient un nombre, il me semble qu'ils voudraient savoir si elle contient un nombre, et 1e + 30 est un nombre. Certes, si je testais une chaîne pour une valeur numérique en JavaScript, je voudrais que cela corresponde.
Dan Jones

9

J'ai testé et la solution de Michael est la meilleure. Votez pour sa réponse ci-dessus (recherchez sur cette page "Si vous voulez vraiment vous assurer qu'une chaîne" pour la trouver). En substance, sa réponse est la suivante:

function isNumeric(num){
  num = "" + num; //coerce num to be a string
  return !isNaN(num) && !isNaN(parseFloat(num));
}

Cela fonctionne pour chaque cas de test, que j'ai documenté ici: https://jsfiddle.net/wggehvp9/5/

La plupart des autres solutions échouent pour ces cas limites: '', null, "", true et []. En théorie, vous pouvez les utiliser avec une gestion des erreurs appropriée, par exemple:

return !isNaN(num);

ou

return (+num === +num);

avec une gestion spéciale pour / \ s /, null, "", true, false, [] (et autres?)


1
Cela revient toujours vrai avec les espaces de fin / de début. Ajouter quelque chose comme ça à l'instruction return résoudrait cela: &&! / ^ \ S + | \ s + $ / g.test (str)
Ultroman the Tacoman

2
Donc «123» devrait être faux, pas un nombre, tandis que «1234» devrait être un nombre? J'aime la façon dont il est, de sorte que "123" est un nombre, mais cela peut être à la discrétion du développeur si les espaces de début ou de fin doivent changer la valeur.
JohnP2

8

Vous pouvez utiliser le résultat de Number lorsque vous passez un argument à son constructeur.

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

Remarques: Notez lorsque vous passez une chaîne vide ou '\t\t'et '\n\t'que Number renvoie 0; La réussite de true renvoie 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

Le Numberconstructeur est exactement le même que +x.
GregRos

En remarque, gardez à l'esprit que l'ES6 Number()gère également les nombres flottants, comme Number.parseFloat()nonNumber.parseInt()
zurfyx

7

Peut-être qu'une ou deux personnes rencontrent cette question qui ont besoin d'un contrôle beaucoup plus strict que d'habitude (comme je l'ai fait). Dans ce cas, cela pourrait être utile:

if(str === String(Number(str))) {
  // it's a "perfectly formatted" number
}

Il faut se méfier! Cela rejette les chaînes comme .1, 40.000, 080, 00.1. C'est très difficile - la chaîne doit correspondre à la " forme parfaite la plus minimale " du nombre pour que ce test réussisse.

Il utilise le constructeur Stringet Numberpour convertir la chaîne en un nombre et inversement et vérifie ainsi si la "forme minimale parfaite" du moteur JavaScript (celle à laquelle il a été converti avec le Numberconstructeur initial ) correspond à la chaîne d'origine.


2
Merci @JoeRocc. Je avais besoin aussi, mais seulement pour des entiers, donc j'ajouté: (str === String(Math.round(Number(str)))).
keithpjolley

Sachez que "Infinity", "-Infinity"et "NaN"passer ce test. Cependant, cela peut être résolu à l'aide d'un Number.isFinitetest supplémentaire .
GregRos

C'est exactement la même chose que str === ("" + +str). Il vérifie essentiellement si la chaîne est le résultat de la chaîne d'un numéro JS. Sachant cela, nous pouvons également voir un problème: le test réussit 0.000001mais échoue 0.0000001, c'est-à-dire quand 1e-7passe à la place. De même pour les très gros nombres.
GregRos

5

parseInt (), mais sachez que cette fonction est un peu différente en ce sens qu'elle retourne par exemple 100 pour parseInt ("100px").


Et 11 pour parseInt(09).
djechlin

10
parce que vous devez utiliserparaseInt(09, 10)
Gavin

1
Depuis ECMAScript 5 , qui prend en charge un large navigateur (IE≥9), vous n'avez plus besoin de l' , 10argument. parseInt('09')est maintenant égal à 9.
Rory O'Kane

4

Citation:

isNaN (num) // renvoie vrai si la variable ne contient PAS de nombre valide

n'est pas entièrement vrai si vous devez vérifier les espaces de début / fin - par exemple lorsqu'une certaine quantité de chiffres est requise, et que vous devez obtenir, par exemple, «1111» et non «111» ou «111» pour peut-être un code PIN contribution.

Mieux utiliser:

var num = /^\d+$/.test(num)

Les valeurs '-1', '0.1'et '1e10'toutes renvoient false. De plus, les valeurs supérieures à l'infini positif ou inférieures à l'infini négatif renvoient true, alors qu'elles devraient probablement renvoyer false.
Rudey

4

Pourquoi l'implémentation de jQuery n'est-elle pas assez bonne?

function isNumeric(a) {
    var b = a && a.toString();
    return !$.isArray(a) && b - parseFloat(b) + 1 >= 0;
};

Michael a suggéré quelque chose comme ça (bien que j'ai volé la version modifiée de "user1691651 - John" ici):

function isNumeric(num){
    num = "" + num; //coerce num to be a string
    return !isNaN(num) && !isNaN(parseFloat(num));
}

Ce qui suit est une solution avec probablement de mauvaises performances, mais des résultats solides. C'est un engin fabriqué à partir de l'implémentation de jQuery 1.12.4 et de la réponse de Michael, avec une vérification supplémentaire pour les espaces de début / fin (car la version de Michael renvoie vrai pour les chiffres avec des espaces de début / fin):

function isNumeric(a) {
    var str = a + "";
    var b = a && a.toString();
    return !$.isArray(a) && b - parseFloat(b) + 1 >= 0 &&
           !/^\s+|\s+$/g.test(str) &&
           !isNaN(str) && !isNaN(parseFloat(str));
};

Cette dernière version a cependant deux nouvelles variables. On pourrait contourner l'un d'entre eux en faisant:

function isNumeric(a) {
    if ($.isArray(a)) return false;
    var b = a && a.toString();
    a = a + "";
    return b - parseFloat(b) + 1 >= 0 &&
            !/^\s+|\s+$/g.test(a) &&
            !isNaN(a) && !isNaN(parseFloat(a));
};

Je n'ai pas testé beaucoup de ceux-ci, autrement que de tester manuellement les quelques cas d'utilisation que je vais rencontrer avec ma situation actuelle, qui est tout à fait standard. Il s'agit d'une situation "debout sur les épaules des géants".


4

Il n'est pas valide pour TypeScript en tant que:

declare function isNaN(number: number): boolean;

Pour TypeScript, vous pouvez utiliser:

/^\d+$/.test(key)


3

Eh bien, j'utilise celui que j'ai fait ...

Cela fonctionne jusqu'à présent:

function checkNumber(value) {
    if ( value % 1 == 0 )
    return true;
    else
    return false;
}

Si vous rencontrez un problème, dites-le moi, s'il vous plaît.


12
Cela donne le mauvais résultat pour la chaîne vide, le tableau vide, false et null.
Ori

2
Cela ne devrait-il pas être un triple égal?
toasted_flakes

1
Dans mon application, nous n'autorisons que az AZ et 0-9 caractères. J'ai trouvé que ce qui précède fonctionnait à moins que la chaîne ne commence par 0xnn, puis il la retournerait sous forme numérique alors qu'elle n'aurait pas dû. J'ai posté dans un commentaire ci-dessous donc la mise en forme est intacte.
rwheadon

6
vous pouvez simplement faire 'return value% 1 === 0'
Brian Schermerhorn

return !isNaN(parseInt(value, 10));
Faites

3

Si quelqu'un arrive aussi loin, j'ai passé du temps à pirater cela en essayant de patcher moment.js ( https://github.com/moment/moment ). Voici quelque chose que j'en ai retiré:

function isNumeric(val) {
    var _val = +val;
    return (val !== val + 1) //infinity check
        && (_val === +val) //Cute coercion check
        && (typeof val !== 'object') //Array/object check
}

Gère les cas suivants:

Vrai! :

isNumeric("1"))
isNumeric(1e10))
isNumeric(1E10))
isNumeric(+"6e4"))
isNumeric("1.2222"))
isNumeric("-1.2222"))
isNumeric("-1.222200000000000000"))
isNumeric("1.222200000000000000"))
isNumeric(1))
isNumeric(0))
isNumeric(-0))
isNumeric(1010010293029))
isNumeric(1.100393830000))
isNumeric(Math.LN2))
isNumeric(Math.PI))
isNumeric(5e10))

Faux! :

isNumeric(NaN))
isNumeric(Infinity))
isNumeric(-Infinity))
isNumeric())
isNumeric(undefined))
isNumeric('[1,2,3]'))
isNumeric({a:1,b:2}))
isNumeric(null))
isNumeric([1]))
isNumeric(new Date()))

Ironiquement, celui avec lequel je lutte le plus:

isNumeric(new Number(1)) => false

Toutes les suggestions sont les bienvenues. :]


2
Et pour isNumeric(' ')et isNumeric('')?
Alex Cory

J'ajouterais && (val.replace(/\s/g,'') !== '') //Empty && (val.slice(-1) !== '.') //Decimal without Numberafin d'aborder le problème mentionné ci-dessus et celui que j'avais moi-même.
frankenapps


3
function isNumberCandidate(s) {
  const str = (''+ s).trim();
  if (str.length === 0) return false;
  return !isNaN(+str);
}

console.log(isNumberCandidate('1'));       // true
console.log(isNumberCandidate('a'));       // false
console.log(isNumberCandidate('000'));     // true
console.log(isNumberCandidate('1a'));      // false 
console.log(isNumberCandidate('1e'));      // false
console.log(isNumberCandidate('1e-1'));    // true
console.log(isNumberCandidate('123.3'));   // true
console.log(isNumberCandidate(''));        // false
console.log(isNumberCandidate(' '));       // false
console.log(isNumberCandidate(1));         // true
console.log(isNumberCandidate(0));         // true
console.log(isNumberCandidate(NaN));       // false
console.log(isNumberCandidate(undefined)); // false
console.log(isNumberCandidate(null));      // false
console.log(isNumberCandidate(-1));        // true
console.log(isNumberCandidate('-1'));      // true
console.log(isNumberCandidate('-1.2'));    // true
console.log(isNumberCandidate(0.0000001)); // true
console.log(isNumberCandidate('0.0000001')); // true
console.log(isNumberCandidate(Infinity));    // true
console.log(isNumberCandidate(-Infinity));    // true

console.log(isNumberCandidate('Infinity'));  // true

if (isNumberCandidate(s)) {
  // use +s as a number
  +s ...
}

Merci, bonne réponse!
M.Abulsoud

3

2019: Y compris les exemples ES3, ES6 et TypeScript

Peut-être que cela a été refait trop souvent, mais j'ai aussi combattu avec celle-ci aujourd'hui et je voulais poster ma réponse, car je n'ai vu aucune autre réponse qui le fasse aussi simplement ou complètement:

ES3

var isNumeric = function(num){
    return (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);  
}

ES6

const isNumeric = (num) => (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);

Manuscrit

const isNumeric = (num: any) => (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num as number);

Cela semble assez simple et couvre toutes les bases que j'ai vues sur les nombreux autres postes et que j'ai imaginé moi-même:

// Positive Cases
console.log(0, isNumeric(0) === true);
console.log(1, isNumeric(1) === true);
console.log(1234567890, isNumeric(1234567890) === true);
console.log('1234567890', isNumeric('1234567890') === true);
console.log('0', isNumeric('0') === true);
console.log('1', isNumeric('1') === true);
console.log('1.1', isNumeric('1.1') === true);
console.log('-1', isNumeric('-1') === true);
console.log('-1.2354', isNumeric('-1.2354') === true);
console.log('-1234567890', isNumeric('-1234567890') === true);
console.log(-1, isNumeric(-1) === true);
console.log(-32.1, isNumeric(-32.1) === true);
console.log('0x1', isNumeric('0x1') === true);  // Valid number in hex
// Negative Cases
console.log(true, isNumeric(true) === false);
console.log(false, isNumeric(false) === false);
console.log('1..1', isNumeric('1..1') === false);
console.log('1,1', isNumeric('1,1') === false);
console.log('-32.1.12', isNumeric('-32.1.12') === false);
console.log('[blank]', isNumeric('') === false);
console.log('[spaces]', isNumeric('   ') === false);
console.log('null', isNumeric(null) === false);
console.log('undefined', isNumeric(undefined) === false);
console.log([], isNumeric([]) === false);
console.log('NaN', isNumeric(NaN) === false);

Vous pouvez également essayer le vôtre isNumeric fonction et juste passer dans ces cas d'utilisation et rechercher «vrai» pour chacun d'eux.

Ou, pour voir les valeurs que chacun renvoie:

Les résultats de chaque test contre <code> isNumeric () </code>


3

2019: Contrôle de validité numérique pratique et précis

Souvent, un «nombre valide» signifie un nombre Javascript excluant NaN et Infinity, c'est-à-dire un «nombre fini».

Pour vérifier la validité numérique d'une valeur (à partir d'une source externe par exemple), vous pouvez définir dans le style ESlint Airbnb:

/**
 * Returns true if 'candidate' is a finite number or a string referring (not just 'including') a finite number
 * To keep in mind:
 *   Number(true) = 1
 *   Number('') = 0
 *   Number("   10  ") = 10
 *   !isNaN(true) = true
 *   parseFloat('10 a') = 10
 *
 * @param {?} candidate
 * @return {boolean}
 */
function isReferringFiniteNumber(candidate) {
  if (typeof (candidate) === 'number') return Number.isFinite(candidate);
  if (typeof (candidate) === 'string') {
    return (candidate.trim() !== '') && Number.isFinite(Number(candidate));
  }
  return false;
}

et utilisez-le de cette façon:

if (isReferringFiniteNumber(theirValue)) {
  myCheckedValue = Number(theirValue);
} else {
  console.warn('The provided value doesn\'t refer to a finite number');
}

2

PFB la solution de travail:

 function(check){ 
    check = check + "";
    var isNumber =   check.trim().length>0? !isNaN(check):false;
    return isNumber;
    }

2

Épargnez-vous le casse-tête d'essayer de trouver une solution «intégrée».

Il n'y a pas de bonne réponse, et la réponse extrêmement votée dans ce fil est fausse.

npm install is-number

En JavaScript, il n'est pas toujours aussi simple qu'il devrait l'être de vérifier de manière fiable si une valeur est un nombre. Il est courant que les développeurs utilisent +, - ou Number () pour convertir une valeur de chaîne en un nombre (par exemple, lorsque les valeurs sont renvoyées par l'entrée utilisateur, les correspondances d'expression régulière, les analyseurs, etc.). Mais il existe de nombreux cas de bord non intuitifs qui donnent des résultats inattendus:

console.log(+[]); //=> 0
console.log(+''); //=> 0
console.log(+'   '); //=> 0
console.log(typeof NaN); //=> 'number'

1

J'ai récemment écrit un article sur les moyens de garantir qu'une variable est un nombre valide: https://github.com/jehugaleahsa/artifacts/blob/master/2018/typescript_num_hack.md L'article explique comment garantir la virgule flottante ou l'entier, si c'est le cas important ( +xvs~~x ).

L'article suppose que la variable est un stringou un numberpour commencer et trimest disponible / polyfilled. Il ne serait pas difficile de l'étendre pour gérer d'autres types également. Voici la viande de celui-ci:

// Check for a valid float
if (x == null
    || ("" + x).trim() === ""
    || isNaN(+x)) {
    return false;  // not a float
}

// Check for a valid integer
if (x == null
    || ("" + x).trim() === ""
    || ~~x !== +x) {
    return false;  // not an integer
}

1

Ma tentative d'un peu déroutant, peut-être pas la meilleure solution

function isInt(a){
    return a === ""+~~a
}


console.log(isInt('abcd'));         // false
console.log(isInt('123a'));         // false
console.log(isInt('1'));            // true
console.log(isInt('0'));            // true
console.log(isInt('-0'));           // false
console.log(isInt('01'));           // false
console.log(isInt('10'));           // true
console.log(isInt('-1234567890'));  // true
console.log(isInt(1234));           // false
console.log(isInt('123.4'));        // false
console.log(isInt(''));             // false

// other types then string returns false
console.log(isInt(5));              // false
console.log(isInt(undefined));      // false
console.log(isInt(null));           // false
console.log(isInt('0x1'));          // false
console.log(isInt(Infinity));       // false

Ce n'est pas trop mal, deux mauvais ça ne fonctionne pour aucune notation non décimale, comme (1) la notation scientifique et (2) la notation non base-10, comme octal ( 042) et hexadécimal ( 0x45f)
Domi

Cela ne répond pas à la question de la recherche d'une valeur numérique, il ne recherche qu'un int.
Jeremy

0

Dans mon application, nous n'autorisons que az AZ et 0-9 caractères. J'ai trouvé la réponse ci-dessus en utilisant " chaîne % 1 === 0" a fonctionné à moins que la chaîne ne commence par 0xnn (comme 0x10) et qu'elle la renvoie sous forme numérique lorsque nous ne le voulons pas. Le simple piège suivant dans ma vérification numérique semble faire l'affaire dans nos cas spécifiques.

function isStringNumeric(str_input){   
    //concat a temporary 1 during the modulus to keep a beginning hex switch combination from messing us up   
    //very simple and as long as special characters (non a-z A-Z 0-9) are trapped it is fine   
    return '1'.concat(str_input) % 1 === 0;}

Avertissement : Cela pourrait exploiter un bogue de longue date dans Javascript et Actionscript [Number ("1" + the_string)% 1 === 0)], je ne peux pas parler pour cela, mais c'est exactement ce dont nous avions besoin.


Pourquoi serait-ce un bug dans JavaScript?
Bergi

Je ne vois tout simplement pas le même comportement avec une solution similaire en perl ou en C, et comme je ne suis pas développeur de langage de programmation pour javascript ou actionscript, je ne sais pas si le comportement que je vis est vraiment intentionnel ou non.
rwheadon

Eh bien, javascript est un peu bâclé sur la conversion de type implicite, mais une fois que vous savez que vous pouvez facilement comprendre comment cela fonctionne. Vous transformez des chaînes en nombres (en invoquant l' % 1opération numérique sur eux), et cela interprétera la chaîne comme un littéral hexadécimal ou flottant.
Bergi

0

Ma solution:

// returns true for positive ints; 
// no scientific notation, hexadecimals or floating point dots

var isPositiveInt = function(str) { 
   var result = true, chr;
   for (var i = 0, n = str.length; i < n; i++) {
       chr = str.charAt(i);
       if ((chr < "0" || chr > "9") && chr != ",") { //not digit or thousands separator
         result = false;
         break;
       };
       if (i == 0 && (chr == "0" || chr == ",")) {  //should not start with 0 or ,
         result = false;
         break;
       };
   };
   return result;
 };

Vous pouvez ajouter des conditions supplémentaires à l'intérieur de la boucle, pour répondre à vos besoins particuliers.


0

Vous pouvez utiliser des types, comme avec la bibliothèque de flux , pour obtenir une vérification statique de l'heure de compilation. Bien sûr, pas terriblement utile pour la saisie des utilisateurs.

// @flow

function acceptsNumber(value: number) {
  // ...
}

acceptsNumber(42);       // Works!
acceptsNumber(3.14);     // Works!
acceptsNumber(NaN);      // Works!
acceptsNumber(Infinity); // Works!
acceptsNumber("foo");    // Error!

0

Voici une ligne pour vérifier s'il sNums'agit d'une valeur numérique valide; il a été testé pour une grande variété d'entrées:

!isNaN(+s.replace(/\s|\$/g, ''));  // returns True if numeric value

0

Utilisez simplement isNaN(), cela convertira la chaîne en un nombre et si vous obtenez un nombre valide , reviendra false...

isNaN("Alireza"); //return true
isNaN("123"); //return false

0

J'utilise ce qui suit:

const isNumber = s => !isNaN(+s)

Works est relativement bien de nombreux cas, mais échoue cas comme 1..1, 1,1, -32.1.12et ne parvient plus important undefinedet NaN. Si vous avez réussi undefinedou NaNque cela vous retournerait un faux positif disant que c'était un nombre.
Jeremy
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.