(Integrierte) Methode in JavaScript, um zu überprüfen, ob eine Zeichenfolge eine gültige Zahl ist

1190

Ich hoffe, es gibt etwas im selben konzeptionellen Raum wie die alte VB6- IsNumeric()Funktion?

Electrons_Ahoy
quelle
3
Siehe diese verwandte Frage , die ich vor einiger Zeit gestellt habe.
Michael Haren
38
Wenn Sie zu dieser Frage gehen, versuchen Sie, alle RegEx-Antworten zu überspringen. Das ist einfach NICHT der richtige Weg.
Joel Coehoorn
14
Es sei denn, man möchte genau das tun: Um zu überprüfen, ob eine bestimmte Zeichenfolge das Format eines gültigen Ziffernstroms hat. Warum sollte es dann falsch sein?
SasQ
17
Die ausgewählte Antwort ist falsch !!! Siehe seine Kommentare, aber im Grunde versagt es zB mit isNaN(""), isNaN(" "), isNaN(false), etc. Es kehrt falsefür diese, was bedeutet , dass sie Zahlen sind.
Andrew
1
Daher ist die ausgewählte Antwort falsch. Regexp ist auch nicht der richtige Weg, dies zu tun. Welches ist dann richtig?
Vir uns

Antworten:

2322

Um zu überprüfen, ob eine Variable (einschließlich einer Zeichenfolge) eine Zahl ist, überprüfen Sie, ob es sich nicht um eine Zahl handelt:

Dies funktioniert unabhängig davon, ob der variable Inhalt eine Zeichenfolge oder eine Zahl ist.

isNaN(num)         // returns true if the variable does NOT contain a valid number

Beispiele

isNaN(123)         // false
isNaN('123')       // false
isNaN('1e10000')   // false (This translates to Infinity, which is a number)
isNaN('foo')       // true
isNaN('10px')      // true

Natürlich können Sie dies bei Bedarf negieren. Um beispielsweise das von IsNumericIhnen angegebene Beispiel zu implementieren :

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

So konvertieren Sie eine Zeichenfolge mit einer Zahl in eine Zahl:

Funktioniert nur, wenn die Zeichenfolge nur numerische Zeichen enthält, andernfalls wird sie zurückgegeben NaN.

+num               // returns the numeric value of the string, or NaN 
                   // if the string isn't purely numeric characters

Beispiele

+'12'              // 12
+'12.'             // 12
+'12..'            // NaN
+'.12'             // 0.12
+'..12'            // NaN
+'foo'             // NaN
+'12px'            // NaN

So konvertieren Sie eine Zeichenfolge lose in eine Zahl

Nützlich für die Konvertierung von '12px' in 12, zum Beispiel:

parseInt(num)      // extracts a numeric value from the 
                   // start of the string, or NaN.

Beispiele

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. 

Schwimmt

Beachten Sie, dass, im Gegensatz zu +num, parseInt(wie der Name schon sagt) ein Schwimmer in eine ganze Zahl konvertieren , indem off alles Zerhacken des ersten Dezimalstelle (wenn Sie verwenden möchten , parseInt() weil dieses Verhalten, sind Sie wahrscheinlich besser dran , eine andere Methode stattdessen verwenden ) ::

+'12.345'          // 12.345
parseInt(12.345)   // 12
parseInt('12.345') // 12

Leere Saiten

Leere Zeichenfolgen können etwas kontraintuitiv sein. +numkonvertiert leere Zeichenfolgen oder Zeichenfolgen mit Leerzeichen in Null und isNaN()setzt dasselbe voraus:

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

Aber parseInt()stimmt nicht zu:

parseInt('')       // NaN
parseInt('   ')    // NaN
Dan
quelle
133
Ein sehr wichtiger Hinweis zu parseInt ist, dass Sie damit einen Radix für die Konvertierung der Zeichenfolge in ein int angeben können. Dies ist ein großes Problem, da es versucht, einen Radix für Sie zu erraten, wenn Sie ihn nicht liefern. Beispiel: parseInt ("17") ergibt 17 (dezimal, 10), parseInt ("08") ergibt 0 (oktal, 8). Sofern Sie nichts anderes beabsichtigen, ist es am sichersten, parseInt (Nummer 10) zu verwenden und 10 explizit als Radix anzugeben.
Adam Raney
36
Beachten Sie, dass! IsNaN (undefined) false zurückgibt.
David Hellsing
111
Das ist einfach falsch - wie kam es zu so vielen positiven Stimmen? Sie können nicht isNaN"Überprüfen, ob eine Variable keine Zahl ist" verwenden. "keine Zahl" ist nicht dasselbe wie "IEEE-794 NaN", worauf isNaNgetestet wird. Insbesondere schlägt diese Verwendung fehl, wenn zumindest Boolesche Werte und leere Zeichenfolgen getestet werden. Siehe developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… .
EML
46
Der schnellstmögliche Weg, um zu überprüfen, ob es sich bei einer Zahl um eine Zahl handelt, ist die Überprüfung "gleich zu sich selbst": var n = 'a'; if (+n === +n) { // is number }Sie ist ~ 3994% schneller als isNaN in der neuesten Version von Chrome. Sehen Sie den Leistungstest hier: jsperf.com/isnan-vs-typeof/5
Kevin Jurkowski
22
** Warnung ** Diese Antwort ist falsch. Benutzung auf eigene Gefahr. Beispiel:isNaN(1 + false + parseInt("1.do you trust your users?"))
keithpjolley
55

Und Sie könnten den RegExp-Weg gehen:

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
}
Roenving
quelle
40
In diesem Fall ist RegExp == schlecht
Joel Coehoorn
10
Dies schlägt bei hexadezimalen Zahlen (z. B. 0x12) fehl, schwebt ohne führende Null (z. B. .42) und mit negativen Zahlen.
Ori
17
@JoelCoehoorn Möchten Sie näher erläutern, warum RegExp == hier schlecht ist? Scheint mir ein gültiger Anwendungsfall zu sein.
Computrius
6
Es gibt mehr Möglichkeiten, als es scheint, eine Zahl zu bilden (Hexadezimalzahlen in einem anderen Kommentar sind nur ein Beispiel), und es gibt viele Zahlen, die möglicherweise nicht als gültig angesehen werden (Überlauf des Typs, zu genau usw.). Außerdem ist Regex sowohl langsamer als auch komplizierter als nur die Verwendung der eingebauten Mechanismen
Joel Coehoorn
1
sollte auch mit der wissenschaftlichen Notation übereinstimmen ... 1e10 usw.
Joseph Merdrignac
51

Wenn Sie nur versuchen zu überprüfen, ob eine Zeichenfolge eine ganze Zahl ist (keine Dezimalstellen), ist Regex ein guter Weg. Andere Methoden wie isNaNsind für etwas so Einfaches zu kompliziert.

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

Um nur positive ganze Zahlen zuzulassen , verwenden Sie Folgendes:

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

console.log(isNumeric('123'));          // true
console.log(isNumeric('-23'));          // false
Gavin
quelle
11
console.log (isNumeric ('- 1'));
Yongnan
5
console.log (isNumeric ('2e2'));
Gaël Barbin
11
Benennen Sie "isNumeric" einfach in "hasOnlyDigits" um. In vielen Fällen ist dies genau der Scheck, den Sie suchen.
Gus3001
1
Dies ist, was ich gesucht habe, das Äquivalent zu php ctype_digit
Miguel Pynto
/^-?\d+$/Recht?
Sukima
36

Wenn Sie wirklich sicherstellen möchten , dass ein String nur eine Zahl enthält, eine beliebige Anzahl (ganze oder Gleitkomma-) und genau eine Nummer, Sie können nicht verwenden parseInt()/ parseFloat(), Number()oder für !isNaN()sich. Beachten Sie, dass !isNaN()tatsächlich zurückgegeben wird, truewann Number()eine Zahl zurückgegeben wird und falsewann sie zurückgegeben NaNwird. Daher werde ich sie vom Rest der Diskussion ausschließen.

Das Problem dabei parseFloat()ist, dass eine Zahl zurückgegeben wird, wenn die Zeichenfolge eine beliebige Zahl enthält, auch wenn die Zeichenfolge nicht nur und genau eine Zahl enthält:

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

Das Problem dabei Number()ist, dass eine Zahl zurückgegeben wird, wenn der übergebene Wert überhaupt keine Zahl ist!

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

Das Problem beim Rollen Ihres eigenen regulären Ausdrucks besteht darin, dass Sie Fälle verpassen oder Fälle erkennen, in denen Sie dies nicht tun sollten, es sei denn, Sie erstellen den genauen regulären Ausdruck für die Übereinstimmung mit einer Gleitkommazahl, wie sie von Javascript erkannt wird. Und selbst wenn Sie Ihren eigenen regulären Ausdruck rollen können, warum? Es gibt einfachere integrierte Möglichkeiten, dies zu tun.

Es stellt sich jedoch heraus, dass Number()(und isNaN()) das Richtige für jeden Fall tun, in dem parseFloat()eine Zahl zurückgegeben wird, wenn dies nicht der Fall sein sollte, und umgekehrt. Um herauszufinden, ob eine Zeichenfolge wirklich genau und nur eine Zahl ist, rufen Sie beide Funktionen auf und prüfen Sie, ob beide true zurückgeben:

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))
}
Michael
quelle
2
Dies gibt true zurück, wenn die Zeichenfolge führende oder nachfolgende Leerzeichen enthält. ' 1', '2 'Und ' 3 'alle return true.
Rudey
Das Hinzufügen von so etwas zur return-Anweisung würde das lösen: &&! / ^ \ S + | \ s + $ / g.test (str)
Ultroman the Tacoman
2
@RuudLenders - Die meisten Leute kümmern sich nicht darum, ob nachgestellte Leerzeichen abgeschnitten werden, um die Zeichenfolge zu einer gültigen Zahl zu machen, da es einfach ist, die zusätzlichen Leerzeichen in vielen Schnittstellen versehentlich einzufügen.
Ian
3
Dies gilt für den Fall, dass die Zahlenfolge aus Benutzereingaben stammt. Aber ich dachte, ich sollte trotzdem Leerzeichen erwähnen, weil ich denke, dass die meisten Leute, die eine isNumberFunktion benötigen , sich nicht mit Benutzeroberflächen befassen. Außerdem lässt eine gute Zahleneingabe zunächst keine Leerzeichen zu.
Rudey
36

Die akzeptierte Antwort auf diese Frage weist einige Mängel auf (wie von einigen anderen Benutzern hervorgehoben). Dies ist eine der einfachsten und bewährten Methoden, um in Javascript darauf zuzugreifen:

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

Nachfolgend einige gute Testfälle:

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
Hamzeen Hameem
quelle
22

Probieren Sie die isNan-Funktion aus :

Die Funktion isNaN () bestimmt, ob ein Wert eine unzulässige Zahl ist (keine Zahl).

Diese Funktion gibt true zurück, wenn der Wert NaN entspricht. Andernfalls wird false zurückgegeben.

Diese Funktion unterscheidet sich von der nummerenspezifischen Number.isNaN () -Methode.

  Die globale Funktion isNaN () konvertiert den getesteten Wert in eine Zahl und testet ihn dann.

Number.isNan () konvertiert die Werte nicht in eine Zahl und gibt für keinen Wert, der nicht vom Typ Number ist, true zurück ...

Theraccoonbear
quelle
2
Stellen Sie sicher, dass Sie eine Prüfung für die leere Zeichenfolge hinzufügen. isNaN ('') gibt false zurück, aber Sie möchten wahrscheinlich, dass es in diesem Fall true zurückgibt.
Michael Haren
3
isFinite ist eine bessere Prüfung - es befasst sich mit dem seltsamen Eckfall von Infinity
JonnyRaa
3
@ MichaelHaren Nicht gut genug! isNaN()Gibt falsefür JEDE Zeichenfolge zurück, die nur Leerzeichen enthält, einschließlich '\ u00A0'.
Michael
1
WARNUNG: Funktioniert nicht für die Werte: null, "" (leere Zeichenfolge) und false.
Jenny O'Reilly
Mir ist klar, dass diese Antwort vor 11 Jahren und einige Minuten vor der akzeptierten gegeben wurde, aber ob es Ihnen gefällt oder nicht, die akzeptierte Antwort hat viel mehr Konversation, so dass diese Antwort der Beantwortung der Frage nicht wirklich etwas hinzufügt. Ich würde freundlicherweise vorschlagen, es zu löschen, um neue Leser nicht abzulenken. Ich denke auch, dass Sie das Disziplin-Abzeichen erhalten, wenn Sie das tun.
Dan Dascalescu
14

Alte Frage, aber in den gegebenen Antworten fehlen einige Punkte.

Wissenschaftliche Schreibweise.

!isNaN('1e+30')ist truejedoch in den meisten Fällen, wenn Menschen nach Zahlen fragen, wollen sie nicht Dinge wie übereinstimmen 1e+30.

Große schwebende Zahlen können sich seltsam verhalten

Beobachten Sie (mit 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
>

Auf der anderen Seite:

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

Wenn Sie also damit rechnen String(Number(s)) === s, sollten Sie Ihre Zeichenfolgen besser auf höchstens 15 Stellen beschränken (nachdem Sie führende Nullen weggelassen haben).

Unendlichkeit

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

Überprüfen Sie vor diesem Hintergrund, ob die angegebene Zeichenfolge eine Zahl ist, die alle folgenden Anforderungen erfüllt:

  • nicht wissenschaftliche Notation
  • vorhersehbare Umstellung auf Numberund zurück zuString
  • endlich

ist keine so einfache Aufgabe. Hier ist eine einfache Version:

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

Allerdings ist auch dieser alles andere als vollständig. Führende Nullen werden hier nicht behandelt, aber sie schrauben den Längen-Test.

Kennzeichen
quelle
1
"In den meisten Fällen, in denen Leute nach Zahlen fragen, möchten sie jedoch nicht mit Dingen wie 1e + 30 übereinstimmen." Warum würden Sie das sagen? Wenn jemand wissen möchte, ob eine Zeichenfolge eine Zahl enthält, möchte er anscheinend wissen, ob sie eine Zahl enthält, und 1e + 30 ist eine Zahl. Wenn ich eine Zeichenfolge in JavaScript auf einen numerischen Wert testen würde, würde ich sicher wollen, dass dies übereinstimmt.
Dan Jones
9

Ich habe getestet und Michaels Lösung ist am besten. Stimmen Sie oben für seine Antwort ab (suchen Sie auf dieser Seite nach "Wenn Sie wirklich sicherstellen möchten, dass eine Zeichenfolge vorhanden ist", um sie zu finden). Im Wesentlichen lautet seine Antwort:

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

Es funktioniert für jeden Testfall, den ich hier dokumentiert habe: https://jsfiddle.net/wggehvp9/5/

Viele der anderen Lösungen schlagen für diese Randfälle fehl: '', null, "", true und []. Theoretisch könnten Sie sie mit der richtigen Fehlerbehandlung verwenden, zum Beispiel:

return !isNaN(num);

oder

return (+num === +num);

mit spezieller Behandlung für / \ s /, null, "", true, false, [] (und andere?)

JohnP2
quelle
1
Dies gibt bei nachgestellten / führenden Leerzeichen immer noch true zurück. Das Hinzufügen von so etwas zur return-Anweisung würde das lösen: &&! / ^ \ S + | \ s + $ / g.test (str)
Ultroman the Tacoman
2
Also sollte '123' falsch sein, keine Zahl, während '1234' eine Zahl sein sollte? Mir gefällt, wie es ist, so dass "123" eine Zahl ist, aber das kann im Ermessen des Entwicklers liegen, wenn führende oder nachfolgende Leerzeichen den Wert ändern sollten.
JohnP2
8

Sie können das Ergebnis von Number verwenden, wenn Sie ein Argument an seinen Konstruktor übergeben.

Wenn das Argument (eine Zeichenfolge) nicht in eine Zahl konvertiert werden kann, gibt es NaN zurück, sodass Sie feststellen können, ob die angegebene Zeichenfolge eine gültige Zahl war oder nicht.

Hinweise: Hinweis beim Übergeben einer leeren Zeichenfolge oder '\t\t'und '\n\t'als Zahl wird 0 zurückgegeben; Wenn Sie true übergeben, wird 1 und false 0 zurückgegeben.

    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
GibboK
quelle
Der NumberKonstruktor ist genau der gleiche wie +x.
GregRos
Beachten Sie als Randnotiz, dass der ES6 auch Number()Float-Nummern verarbeitet, wie Number.parseFloat()nichtNumber.parseInt()
zurfyx
7

Vielleicht stoßen ein oder zwei Personen auf diese Frage, die eine viel strengere Prüfung als gewöhnlich benötigen (wie ich). In diesem Fall kann dies nützlich sein:

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

In acht nehmen! Dies wird ablehnen Strings wie .1, 40.000, 080, 00.1. Es ist sehr wählerisch - die Saite muss mit der " minimalsten perfekten Form " übereinstimmen " der Zahl damit dieser Test bestanden wird.

Es verwendet den Konstruktor Stringund Number, um die Zeichenfolge in eine Zahl und wieder zurück umzuwandeln, und prüft somit, ob die "perfekte Minimalform" der JavaScript-Engine (diejenige, in die sie mit dem ursprünglichen NumberKonstruktor konvertiert wurde ) mit der ursprünglichen Zeichenfolge übereinstimmt.


quelle
2
Danke @JoeRocc. Ich brauchte das auch, aber nur für ganze Zahlen, also fügte ich hinzu : (str === String(Math.round(Number(str)))).
Keithpjolley
Beachten Sie, dass "Infinity", "-Infinity"und "NaN"diesen Test bestehen. Dies kann jedoch durch einen zusätzlichen Number.isFiniteTest behoben werden .
GregRos
Dies ist genau das gleiche wie str === ("" + +str). Grundsätzlich wird geprüft, ob die Zeichenfolge das Ergebnis der Zeichenfolge einer JS-Nummer ist. Wenn wir dies wissen, können wir auch ein Problem erkennen: Der Test besteht für 0.000001, schlägt jedoch fehl 0.0000001, wenn er 1e-7stattdessen bestanden wird. Das gleiche gilt für sehr große Zahlen.
GregRos
5

parseInt (), aber beachten Sie, dass diese Funktion etwas anders ist, da sie beispielsweise 100 für parseInt ("100px") zurückgibt.

liggett78
quelle
Und 11 für parseInt(09).
Djechlin
10
weil Sie verwenden müssenparaseInt(09, 10)
Gavin
1
Ab ECMAScript 5 , das eine breite Browserunterstützung (IE≥9) bietet, benötigen Sie das , 10Argument nicht mehr. parseInt('09')jetzt gleich 9.
Rory O'Kane
4

Zitat:

isNaN (num) // gibt true zurück, wenn die Variable KEINE gültige Zahl enthält

Dies ist nicht ganz richtig, wenn Sie nach führenden / nachfolgenden Leerzeichen suchen müssen - beispielsweise wenn eine bestimmte Anzahl von Ziffern erforderlich ist und Sie beispielsweise '1111' und nicht '111' oder '111' für möglicherweise eine PIN erhalten müssen Eingang.

Besser zu verwenden:

var num = /^\d+$/.test(num)
Siubear
quelle
Die Werte '-1', '0.1'und '1e10'alle return false. Darüber hinaus geben Werte größer als positive Unendlichkeit oder kleiner als negative Unendlichkeit true zurück, während sie wahrscheinlich false zurückgeben sollten.
Rudey
4

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 so etwas vor (obwohl ich hier die geänderte Version von "user1691651 - John" gestohlen habe):

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

Das Folgende ist eine Lösung mit höchstwahrscheinlich schlechter Leistung, aber soliden Ergebnissen. Es handelt sich um eine Erfindung aus der Implementierung von jQuery 1.12.4 und Michaels Antwort mit einer zusätzlichen Überprüfung für führende / nachfolgende Leerzeichen (da Michaels Version für Zahlen mit führenden / nachfolgenden Leerzeichen true 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 letztere Version hat jedoch zwei neue Variablen. Man könnte eines davon umgehen, indem man:

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 keines dieser Verfahren sehr oft getestet, außer durch manuelles Testen der wenigen Anwendungsfälle, die ich mit meiner aktuellen Situation treffen werde, was alles sehr Standard ist. Dies ist eine Situation, in der Riesen auf den Schultern stehen.

Ultroman der Tacoman
quelle
4

Es ist nicht gültig für TypeScript als:

declare function isNaN(number: number): boolean;

Für TypeScript können Sie Folgendes verwenden:

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

Greg Woz
quelle
3

Nun, ich benutze dieses, das ich gemacht habe ...

Es hat bisher funktioniert:

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

Wenn Sie ein Problem damit feststellen, sagen Sie es mir bitte.

Rafael
quelle
12
Dies ergibt das falsche Ergebnis für die leere Zeichenfolge, das leere Array, false und null.
Ori
2
Sollte es nicht ein Triple Equal sein?
Toasted_flakes
1
In meiner Anwendung erlauben wir nur az AZ und 0-9 Zeichen. Ich fand, dass das Obige funktioniert, es sei denn, die Zeichenfolge begann mit 0xnn und gab sie dann als numerisch zurück, wenn dies nicht der Fall sein sollte. Ich habe unten einen Kommentar gepostet, damit die Formatierung intakt ist.
Rwheadon
6
Sie könnten einfach 'Rückgabewert% 1 === 0' tun
Brian Schermerhorn
Tun return !isNaN(parseInt(value, 10));
Sie es
3

Wenn jemand jemals so weit unten kommt, habe ich einige Zeit damit verbracht, mich mit dem Versuch zu beschäftigen, moment.js ( https://github.com/moment/moment ) zu patchen . Hier ist etwas, das ich weggenommen habe:

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

Behandelt die folgenden Fälle:

Wahr! ::

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

Falsch! ::

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

Ironischerweise derjenige, mit dem ich am meisten zu kämpfen habe:

isNumeric(new Number(1)) => false

Anregungen sind willkommen. :]

Der Dembinski
quelle
2
Was ist mit isNumeric(' ')und isNumeric('')?
Alex Cory
Ich würde hinzufügen, && (val.replace(/\s/g,'') !== '') //Empty && (val.slice(-1) !== '.') //Decimal without Numberum das oben erwähnte Problem und eines, das ich selbst hatte, anzusprechen.
Frankenapps
3

Verwenden von einfachem JavaScript:

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

Verwenden von Lodash:

_.isNaN(_.toNumber('1')); // false
_.isNaN(_.toNumber('asdf')); // true
Abtin Gramian
quelle
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 ...
}
gvlax
quelle
Vielen Dank, tolle Antwort!
M.Abulsoud
3

2019: Einschließlich ES3-, ES6- und TypeScript-Beispiele

Vielleicht wurde dies zu oft wiederholt, aber ich habe heute auch mit dieser gekämpft und wollte meine Antwort posten, da ich keine andere Antwort gesehen habe, die es so einfach oder gründlich macht:

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

Typoskript

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

Dies scheint recht einfach zu sein und deckt alle Grundlagen ab, die ich auf den vielen anderen Posts gesehen und mir selbst ausgedacht habe:

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

Sie können auch Ihre eigene isNumericFunktion ausprobieren und in diesen Anwendungsfällen einfach vorbei gehen und für alle nach "true" suchen .

Oder um die Werte anzuzeigen, die jeweils zurückgegeben werden:

Ergebnisse jedes Tests gegen <code> isNumeric () </ code>

Jeremy
quelle
3

2019: Praktische und strenge numerische Gültigkeitsprüfung

Oft bedeutet eine "gültige Zahl" eine Javascript-Zahl ohne NaN und Infinity, dh eine "endliche Zahl".

Um die numerische Gültigkeit eines Werts zu überprüfen (z. B. von einer externen Quelle), können Sie Folgendes im 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 benutze es so:

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

PFB die Arbeitslösung:

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

Sparen Sie sich die Kopfschmerzen beim Versuch, eine "integrierte" Lösung zu finden.

Es gibt keine gute Antwort und die äußerst positive Antwort in diesem Thread ist falsch.

npm install is-number

In JavaScript ist es nicht immer so einfach, zuverlässig zu prüfen, ob ein Wert eine Zahl ist. Es ist üblich, dass Entwickler +, - oder Number () verwenden, um einen Zeichenfolgenwert in eine Zahl umzuwandeln (z. B. wenn Werte von Benutzereingaben, Regex-Übereinstimmungen, Parsern usw. zurückgegeben werden). Es gibt jedoch viele nicht intuitive Randfälle, die zu unerwarteten Ergebnissen führen:

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

Ich habe kürzlich einen Artikel über Möglichkeiten geschrieben, um sicherzustellen, dass eine Variable eine gültige Zahl ist: https://github.com/jehugaleahsa/artifacts/blob/master/2018/typescript_num_hack.md In diesem Artikel wird erläutert, wie Sie Gleitkomma oder Ganzzahl sicherstellen können, wenn dies der Fall ist wichtig ( +xvs.~~x ).

Der Artikel geht davon aus, dass die Variable zunächst a stringoder a ist numberund trimverfügbar / polygefüllt ist. Es wäre nicht schwer, es auch auf andere Typen auszudehnen. Hier ist das Fleisch davon:

// 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
}
Travis Parks
quelle
1

Mein Versuch einer etwas verwirrenden, vielleicht nicht die beste Lösung

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
Endlos
quelle
Es ist nicht schlecht, zwei schlecht, es funktioniert nicht für eine nicht-dezimale Notation wie (1) wissenschaftliche Notation und (2) nicht-Base-10-Notation wie oktal ( 042) und hexadezimal ( 0x45f)
Domi
Dies beantwortet nicht die Frage nach einem numerischen Wert, sondern nur nach einem int.
Jeremy
0

In meiner Anwendung erlauben wir nur az AZ und 0-9 Zeichen. Ich fand die Antwort oben mit " string % 1 === 0" funktioniert, es sei denn, der String begann mit 0xnn (wie 0x10) und gab ihn dann als numerisch zurück, wenn wir es nicht wollten. Die folgende einfache Falle in meiner numerischen Prüfung scheint in unseren speziellen Fällen den Trick zu tun.

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

Warnung : Dies könnte einen langjährigen Fehler in Javascript und Actionscript [Number ("1" + the_string)% 1 === 0)] ausnutzen. Ich kann nicht dafür sprechen, aber es ist genau das, was wir brauchten.

rwheadon
quelle
Warum sollte das ein Fehler in JavaScript sein?
Bergi
Ich sehe einfach nicht dasselbe Verhalten mit einer ähnlichen Lösung in Perl oder C, und da ich kein Programmiersprachenentwickler für Javascript oder Actionscript bin, weiß ich nicht, ob das Verhalten, das ich erlebe, wirklich beabsichtigt ist oder nicht.
Rwheadon
Nun, Javascript ist ein bisschen schlampig in Bezug auf implizites Casting, aber sobald Sie wissen, dass Sie leicht verstehen können, wie es funktioniert. Sie wandeln Zeichenfolgen in Zahlen um (indem Sie die numerische % 1Operation aufrufen ), und dies interpretiert die Zeichenfolge als Hex- oder Float-Literal.
Bergi
0

Meine Lösung:

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

Sie können zusätzliche Bedingungen innerhalb der Schleife hinzufügen, um Ihren speziellen Anforderungen gerecht zu werden.

Gehe zu
quelle
0

Sie können Typen wie die Flussbibliothek verwenden , um eine statische Überprüfung der Kompilierungszeit zu erhalten. Natürlich nicht besonders nützlich für Benutzereingaben.

// @flow

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

acceptsNumber(42);       // Works!
acceptsNumber(3.14);     // Works!
acceptsNumber(NaN);      // Works!
acceptsNumber(Infinity); // Works!
acceptsNumber("foo");    // Error!
Was wäre cool
quelle
0

Hier ist ein Einzeiler, um zu überprüfen, ob sNumes sich um einen gültigen numerischen Wert handelt. Es wurde für eine Vielzahl von Eingaben getestet:

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

Verwenden Sie einfach isNaN(), dies konvertiert die Zeichenfolge in eine Zahl und wenn Sie eine gültige Zahl erhalten , wird zurückgegeben false...

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

Ich benutze folgendes:

const isNumber = s => !isNaN(+s)
Haxpanel
quelle
Arbeitet relativ gut viele Fälle, aber nicht solche Fälle 1..1, 1,1, -32.1.12, und was noch wichtiger ausfällt undefinedund NaN. Wenn Sie bestanden haben undefinedoder ein, NaNdass es Ihnen ein falsch positives Sprichwort zurückgeben würde, war es eine Zahl.
Jeremy