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

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

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
}

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

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

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

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

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.

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

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

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.

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

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)

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

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

declare function isNaN(number: number): boolean;

Pour TypeScript, vous pouvez utiliser:

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

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.

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. :]

Utilisation de JavaScript simple:

Number.isNaN(Number('1')); // false
Number.isNaN(Number('asdf')); // true

Utilisation de Lodash:

_.isNaN(_.toNumber('1')); // false
_.isNaN(_.toNumber('asdf')); // true

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

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:

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');
}

PFB la solution de travail:

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

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

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
}

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

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.

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.

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!

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

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

J'utilise ce qui suit:

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