Wie kann ich prüfen, ob eine Zeichenkette eine gültige Zahl ist?

Question

Ich hoffe, dass es etwas gibt, das sich im gleichen konzeptionellen Rahmen bewegt wie das alte VB6 IsNumeric() Funktion?

Answer 1

Jemand kann auch von einer Regex-basierten Antwort profitieren. Hier ist sie:

Eine Zeile isInteger:

const isInteger = num => /^-?[0-9]+$/.test(num+'');

Einzeiler istNumerisch: Akzeptiert ganze Zahlen und Dezimalzahlen

const isNumeric = num => /^-?[0-9]+(?:\.[0-9]+)?$/.test(num+'');

Answer 2

Sie können das Ergebnis von Nummer bei der Übergabe eines Arguments an seinen Konstruktor.

Wenn das Argument (eine Zeichenkette) nicht in eine Zahl umgewandelt werden kann, wird NaN zurückgegeben, so dass Sie feststellen können, ob die angegebene Zeichenkette eine gültige Zahl ist oder nicht.

Anmerkungen: Hinweis bei Übergabe eines leeren Strings oder '\t\t' y '\n\t' as Number gibt 0 zurück; die Übergabe von true ergibt 1 und false ergibt 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

Answer 3

Vielleicht gibt es ein oder zwei Personen, die auf diese Frage stoßen und einen Rat brauchen wesentlich strenger prüfen als sonst (wie ich). In diesem Fall könnte dies nützlich sein:

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

Aufgepasst! Dadurch werden Zeichenketten wie .1 , 40.000 , 080 , 00.1 . Es ist sehr wählerisch - die Zeichenkette muss mit dem " minimalste perfekte Form "der Zahl für das Bestehen dieses Tests.

Es verwendet die String y Number Konstruktor, um die Zeichenkette in eine Zahl und wieder zurück umzuwandeln, und prüft so, ob die "perfekte Minimalform" der JavaScript-Engine (diejenige, in die sie mit der ursprünglichen Number Konstruktor) mit der ursprünglichen Zeichenkette übereinstimmt.

Answer 4

2019: Praktische und strenge numerische Gültigkeitsprüfung

Oft bedeutet eine "gültige Zahl" eine Javascript-Zahl außer NaN und Infinity, also eine "endliche Zahl".

Um die numerische Gültigkeit eines Wertes (z.B. aus einer externen Quelle) zu überprüfen, können Sie in ESlint Airbnb-Stil definieren:

/**
 * 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;
}

und verwenden Sie es auf diese Weise:

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

Answer 5

Warum ist die Implementierung von jQuery nicht gut genug?

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

Michael schlug etwas Ähnliches vor (obwohl ich hier die abgeänderte Version von "user1691651 - John" geklaut habe):

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

Im Folgenden finden Sie eine Lösung mit wahrscheinlich schlechter Leistung, aber soliden Ergebnissen. Es ist eine Kombination aus der jQuery 1.12.4-Implementierung und Michaels Antwort, mit einer zusätzlichen Prüfung auf führende/nachlaufende Leerzeichen (weil Michaels Version true für Zahlen mit führenden/nachlaufenden Leerzeichen zurückgibt):

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

Die letztgenannte Version enthält jedoch zwei neue Variablen. Eine davon könnte man umgehen, indem man es tut:

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

Ich habe noch nicht viel davon getestet, mit anderen Mitteln als dem manuellen Testen der wenigen Anwendungsfälle, auf die ich mit meiner aktuellen Situation stoßen werde, was alles sehr standardmäßig ist. Dies ist eine "Stehen-auf-den-Schultern-der-Riesen"-Situation.