Dans Typescript, comment vérifier si une chaîne est numérique

Dans Typescript, cela montre une erreur indiquant que isNaN n'accepte que les valeurs numériques

isNaN('9BX46B6A')

et cela retourne false car il parseFloat('9BX46B6A')évalue à9

isNaN(parseFloat('9BX46B6A'))

Je peux toujours exécuter avec l'erreur apparaissant dans Visual Studio, mais j'aimerais le faire de la bonne manière.

Actuellement, j'ai écrit cette fonction modifiée -

static isNaNModified = (inputStr: string) => {
    var numericRepr = parseFloat(inputStr);
    return isNaN(numericRepr) || numericRepr.toString().length != inputStr.length;
}

La façon de convertir une chaîne en nombre est avec Number, pas parseFloat.

Number('1234') // 1234
Number('9BX9') // NaN

Vous pouvez également utiliser l'opérateur unaire plus si vous aimez la sténographie:

+'1234' // 1234
+'9BX9' // NaN

Soyez prudent lors de la vérification par rapport à NaN (l'opérateur ===et !==ne fonctionne pas comme prévu avec NaN). Utilisation:

 isNaN(maybeNumber) // returns true if NaN, otherwise false

Mise à jour 2

Cette méthode n'est plus disponible dans rxjs v6

Je suis résolu en utilisant le isNumeric opérateur de rxjs bibliothèque (importation rxjs / util / isNumeric

Mettre à jour

import { isNumeric } from 'rxjs/util/isNumeric';

. . .

var val = "5700";
if (isNumeric(val)){
   alert("it is number !");
}

function isNumber(value: string | number): boolean
{
   return ((value != null) &&
           (value !== '') &&
           !isNaN(Number(value.toString())));
}

Réponse simple: (surveillez les blancs et les null)

isNaN(+'111') = false;
isNaN(+'111r') = true;
isNaN(+'r') = true;
isNaN(+'') = false;   
isNaN(null) = false;   

https://codepen.io/CQCoder/pen/zYGEjxd?editors=1111

Je choisirais une solution existante et déjà testée. Par exemple ceci à partir de rxjs en typographie:

function isNumeric(val: any): val is number | string {
  // parseFloat NaNs numeric-cast false positives (null|true|false|"")
  // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
  // subtraction forces infinities to NaN
  // adding 1 corrects loss of precision from parseFloat (#15100)
  return !isArray(val) && (val - parseFloat(val) + 1) >= 0;
}

rxjs / isNumeric.ts

Sans la fonction rxjs isArray () et avec des typages simples:

function isNumeric(val: any): boolean {
  return !(val instanceof Array) && (val - parseFloat(val) + 1) >= 0;
}

Vous devez toujours tester ces fonctions avec vos cas d'utilisation. Si vous avez des types de valeur spéciaux, cette fonction n'est peut-être pas votre solution. Vous pouvez tester la fonction ici.

Les résultats sont:

enum         : CardTypes.Debit   : true
decimal      : 10                : true
hexaDecimal  : 0xf10b            : true
binary       : 0b110100          : true
octal        : 0o410             : true
stringNumber : '10'              : true

string       : 'Hello'           : false
undefined    : undefined         : false
null         : null              : false
function     : () => {}          : false
array        : [80, 85, 75]      : false
turple       : ['Kunal', 2018]   : false
object       : {}                : false

Comme vous pouvez le voir, vous devez être prudent si vous utilisez cette fonction avec des énumérations.

La plupart du temps, la valeur que nous voulons vérifier est une chaîne ou un nombre, voici donc la fonction que j'utilise:

const isNumber = (n: string | number): boolean => 
    !isNaN(parseFloat(String(n))) && isFinite(Number(n));

Tests de codesandbox .

const willBeTrue = [0.1, '1', '-1', 1, -1, 0, -0, '0', "-0", 2e2, 1e23, 1.1, -0.1, '0.1', '2e2', '1e23', '-0.1', ' 898', '080']

const willBeFalse = ['9BX46B6A', "+''", '', '-0,1', [], '123a', 'a', 'NaN', 1e10000, undefined, null, NaN, Infinity, () => {}]

Vous pouvez utiliser la Number.isFinite()fonction:

Number.isFinite(Infinity);  // false
Number.isFinite(NaN);       // false
Number.isFinite(-Infinity); // false
Number.isFinite('0');       // false
Number.isFinite(null);      // false

Number.isFinite(0);         // true
Number.isFinite(2e64);      // true

Remarque: il existe une différence significative entre la fonction globale isFinite()et cette dernière Number.isFinite(). Dans le cas du premier, la coercition des cordes est exécutée - donc isFinite('0') === truealors queNumber.isFinite('0') === false .

Notez également que ce n'est pas disponible dans IE!

Pour les nombres complets (non flottants) dans Angular, vous pouvez utiliser:

if (Number.isInteger(yourVariable)) { ... }

La question de savoir si une chaîne peut être analysée en tant que nombre est un problème d'exécution. Typescript ne prend pas en charge ce cas d'utilisation car il est axé sur la sécurité au moment de la compilation (et non à l'exécution).