(Intégré) JavaScript pour vérifier si une chaîne de caractères est un nombre valide

Et vous pouvez aller la 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
}

si vous voulez vraiment vous assurer qu'une chaîne contient seulement un nombre, n'importe quel nombre (entier ou point flottant), et exactement un nombre, vous ne peut pas utiliser parseInt() / parseFloat() , Number() , ou !isNaN() par eux-mêmes. Notez que !isNaN() renvoie en fait true alors que Number() renvoie un nombre, et false quand il renvoie NaN , 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 un 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 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 rouler votre propre regex est que, à moins que vous créer le regex exact pour correspondre à un nombre de 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 lancer votre propre regex, pourquoi? Il y a de plus simple intégré façons de le faire.

cependant, il s'avère que Number() (et isNaN() ) fait la bonne chose pour chaque cas où parseFloat() retourne un nombre alors qu'il ne devrait pas, et vice versa. Donc, pour savoir si une chaîne est vraiment exactement et seulement un numéro, appeler les deux fonctions et voir si elles 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))
}

Si vous êtes juste essayer de vérifier si une chaîne est un nombre entier (sans décimale), regex est une bonne façon d'aller. D'autres méthodes telles que isNaN sont trop compliquées 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

Pour ne permettre que 151960920" positif des nombres entiers utiliser ceci:

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

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

Essayez le isNan fonction :

la fonction isNaN() détermine si une valeur est un nombre illégal (pas-un-nombre).

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

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

Le mondial isNaN() fonction, convertit la valeur testée en un nombre, puis La Teste.

Numéro

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

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

notation Scientifique.

!isNaN('1e+30') signifie true .

les grands nombres flottants peuvent se comporter bizarrement

observer(en utilisant le noeud.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 plus (après avoir omis les zéros de tête).

l'Infini

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

étant donné tout cela, vérifier que la chaîne donnée est un nombre satisfaisant tous les suivants:

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

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 celle-ci est loin d'être complète. Les zéros de tête ne sont pas manipulés ici, mais ils vissent le test de longueur.

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

vous pouvez utiliser le résultat de nombre en passant un argument à son constructeur.

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

Notes: Note en passant la chaîne vide ou '\t\t' et '\n\t' comme nombre retournera 0; en passant vrai retournera 1 et les retours faux 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

peut-être qu'il y a une ou deux personnes qui rencontrent cette question et qui ont besoin d'une vérification beaucoup plus stricte 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
}

attention! Cela rejettera 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 de ce test pour réussir.

il utilise les constructeurs String et Number pour lancer la chaîne Vers un nombre et vice versa et vérifie ainsi si la" forme minimale parfaite "du moteur JavaScript (celle à laquelle il a été converti avec le constructeur initial Number ) correspond à la chaîne originale.

j'ai testé et la solution de Michael est la meilleure. Votez pour sa réponse ci-dessus (rechercher cette page pour "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));
}

il fonctionne pour chaque cas d'essai, que j'ai documenté ici: https://jsfiddle.net/wggehvp9/5 /

beaucoup d'autres solutions échouent pour ces cas de bord: '', null, "", true, et []. En théorie, vous pourriez les utiliser, avec une bonne gestion des erreurs, par exemple:

return !isNaN(num);

ou

return (+num === +num);

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

J'utilise celui que j'ai fait...

ça a marché jusqu'à présent:

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

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

citation:

isNaN (num) / / retourne true si la variable ne contient pas de nombre valide

n'est pas tout à fait vrai si vous devez vérifier pour les espaces de tête/de fuite - par exemple quand une certaine quantité de chiffres est nécessaire, et vous devez obtenir, disons, '1111' et non '111' ou '111' pour peut-être une entrée de NIP.

à utiliser de préférence:

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

pourquoi la mise en œuvre de jQuery n'est-elle pas suffisante?

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

Michael suggéra quelque chose comme ceci (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 très probablement de mauvaises performances, mais des résultats solides. Il s'agit d'une construction faite à partir de l'implémentation jQuery 1.12.4 et de la réponse de Michael, avec un contrôle supplémentaire pour les espaces de tête/arrière (parce que la version de Michael renvoie true pour les nombres 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 comporte cependant deux nouvelles variables. On pourrait En contourner un, 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 testé aucun de ceux-ci beaucoup, par d'autres moyens que de tester manuellement les quelques cas d'utilisation que je vais frapper avec mon actuelle situation difficile, qui est tout des trucs très standard. Il s'agit d'une situation" debout sur les épaules de géants".

PFB la solution de travail:

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

mon essai à une légère confusion, Pherhaps 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));           // true
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

si quelqu'un arrive à descendre aussi bas, j'ai passé un certain temps à pirater ce moment en essayant de rafistoler.js ( ) https://github.com/moment/moment ). Voici quelque chose que je lui ai pris:

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

S'occupe des 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 qui je lutte le plus:

isNumeric(new Number(1)) => false

toute suggestion est la bienvenue. :]

j'aime la simplicité de cette.

Number.isNaN(Number(value))

le Javascript ci-dessus est régulier, mais je l'utilise en conjonction avec un typeguard pour le contrôle de type intelligent. C'est très utile pour le compilateur de caractères pour vous donner intellisense correct, et pas d'erreurs de type.

Typescript typeguards

isNotNumber(value: string | number): value is string {
    return Number.isNaN(Number(this.smartImageWidth));
}
isNumber(value: string | number): value is number {
    return Number.isNaN(Number(this.smartImageWidth)) === false;
}

disons que vous avez une propriété width qui est number | string . Vous pouvez vouloir faire la logique basée sur si oui ou non c'est une chaîne.

var width: number|string;
width = "100vw";

if (isNotNumber(width)) 
{
    // the compiler knows that width here must be a string
    if (width.endsWith('vw')) 
    {
        // we have a 'width' such as 100vw
    } 
}
else 
{
    // the compiler is smart and knows width here must be number
    var doubleWidth = width * 2;    
}

le typeguard est assez intelligent pour limiter le type de width dans l'énoncé if à string . Cela permet au compilateur d'autoriser width.endsWith(...) ce qu'il ne permettrait pas si le type était string | number .

vous pouvez appeler le typeguard ce que vous voulez isNotNumber , isNumber , isString , isNotString mais je pense que isString est un peu ambigu et plus difficile à lire.

dans mon application, nous n'acceptons que les caractères a-z A-Z et 0-9. J'ai trouvé la réponse ci-dessus en utilisant la chaîne % 1 === 0" fonctionnait à moins que la chaîne commence avec 0xnn (comme 0x10) et ensuite elle retournerait comme numérique quand nous ne le voulions pas. Le piège simple 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 bug de longue date dans Javascript et Actionscript [nombre ("1" + the_string) % 1 === 0)], Je ne peux pas parler pour ça, mais c'est exactement ce dont nous avions besoin.