wake-up-neo.com

(Integrierte) Möglichkeit, in JavaScript zu überprüfen, ob eine Zeichenfolge eine gültige Zahl ist

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

882
Electrons_Ahoy

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

Dies funktioniert unabhängig davon, ob die Variable eine Zeichenfolge oder eine Zahl enthält.

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 auch negieren, wenn Sie dies brauchen. Um beispielsweise das von Ihnen angegebene IsNumeric zu implementieren:

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

So konvertieren Sie eine Zeichenfolge, die eine Nummer enthält, in eine Nummer:

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

+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

Eine Zeichenfolge lose in eine Zahl umwandeln

nützlich für die Umwandlung 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 +numparseInt (wie der Name vermuten lässt) ein Float in eine Ganzzahl konvertiert, indem Sie alles abschneiden, das dem Dezimalpunkt folgt (wenn Sie parseInt()wegen dieses Verhalten verwenden möchten, Es ist wahrscheinlich besser, wenn Sie stattdessen eine andere Methode verwenden ):

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

Leere Zeichenfolgen

Leere Zeichenfolgen können ein wenig kontrapunktisch sein. +num konvertiert leere Zeichenfolgen in Null, und isNaN() geht davon aus:

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

Aber parseInt() stimmt nicht zu:

parseInt('')       // NaN
1841
Dan

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
}
39
roenving

Wenn Sie wirklich sicherstellen möchten, dass eine Zeichenfolge nur eine Zahl, eine beliebige Zahl (Ganzzahl oder Gleitkommazahl) und genau eine Zahl enthält, verwenden Sie kann nichtparseInt()/parseFloat(), Number() oder !isNaN(). Beachten Sie, dass !isNaN() tatsächlich true zurückgibt, wenn Number() eine Zahl zurückgeben würde, und false, wenn NaN zurückgegeben werden würde. Ich werde sie daher vom Rest der Diskussion ausschließen.

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

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

Das Problem mit Number() ist, dass es eine Zahl zurückgibt, wenn der übergebene Wert keine Zahl ist!

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

Das Problem beim Rollen Ihres eigenen Regex ist, dass, wenn Sie nicht den exakten Regex für den Abgleich mit einer Gleitkommazahl erstellen, da Javascript dies erkennt, Sie Fälle verpassen oder Fälle erkennen, in denen Sie dies nicht sollten. Und selbst wenn Sie Ihre eigene Regex ausrollen können, warum? Es gibt einfachere integrierte Möglichkeiten, dies zu tun.

Es stellt sich jedoch heraus, dass Number() (und isNaN()) in jedem Fall das Richtige tut, wenn parseFloat() eine Zahl zurückgibt, wenn dies nicht der Fall ist, und umgekehrt. Um herauszufinden, ob ein String wirklich genau und nur eine Zahl ist, rufen Sie beide Funktionen auf und sehen 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))
}
27
Michael

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

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

Versuchen Sie die isNan-Funktion :

Die Funktion isNaN () bestimmt, ob ein Wert eine ungültige Zahl ist (Not-a-Number).

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

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

Die globale Funktion isNaN () konvertiert den getesteten Wert in eine Zahl und testet sie anschließend.

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

20
theraccoonbear

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

Wissenschaftliche Schreibweise.

!isNaN('1e+30') ist true, aber in den meisten Fällen möchten Personen, die nach Zahlen fragen, keine Übereinstimmung wie 1e+30 herstellen.

Große Floating-Nummern können sich komisch verhalten

Beachten 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 String(Number(s)) === s erwarten, begrenzen Sie Ihre Zeichenfolgen besser auf höchstens 15 Stellen (nachdem Sie führende Nullen weggelassen haben).

Unendlichkeit

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

Wenn Sie das alles überprüfen, überprüfen Sie, ob der angegebene String eine Zahl ist, die alle der folgenden Bedingungen erfüllt:

  • nicht wissenschaftliche Notation
  • vorhersagbare Umwandlung in Number und zurück in String
  • endlich

ist keine so leichte 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);
  }

Aber auch diese ist noch lange nicht abgeschlossen. Führende Nullen werden hier nicht behandelt, aber sie schrauben den Längentest ab.

10
mark

Vielleicht stoßen ein oder zwei Leute auf diese Frage, die einen viel strengerenCheck benötigen als üblich (wie ich). In diesem Fall könnte dies nützlich sein:

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

In acht nehmen! Dadurch werden Zeichenfolgen wie .1, 40.000, 080, 00.1 zurückgewiesen. Es ist sehr wählerisch - die Zeichenfolge muss mit dem Wert "minimalste perfekte Form" übereinstimmen, damit dieser Test bestehen kann.

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

6
user993683

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

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
6
Hamzeen Hameem

Ich habe getestet und Michaels Lösung ist am besten. Stimmen Sie für seine Antwort oben ab (suchen Sie auf dieser Seite nach "Wenn Sie wirklich sicherstellen möchten, dass eine Zeichenfolge gefunden wird"). 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 in diesen Edge-Fällen fehl: ' ', null, "", "true" und [] . Theoretisch könnten Sie sie mit der korrekten Fehlerbehandlung verwenden, zum Beispiel:

return !isNaN(num);

oder

return (+num === +num);

mit besonderer Behandlung für /\ s /, null, "", wahr, falsch, [] (und andere?)

5
JohnP2

parseInt (), beachten Sie jedoch, dass diese Funktion etwas anders ist, als sie zum Beispiel 100 für parseInt ("100px") zurückgibt.

5
liggett78

Nun, ich verwende diesen, den ich gemacht habe ...

Es hat bisher gearbeitet:

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

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

4
Rafael

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 umgewandelt werden kann, wird NaN zurückgegeben. Sie können also bestimmen, ob die angegebene Zeichenfolge eine gültige Zahl ist oder nicht.

Hinweise: Wenn Sie einen leeren String übergeben oder '\t\t' und '\n\t' als Number übergeben, wird 0 zurückgegeben. Wenn Sie true übergeben, wird 1 zurückgegeben, und false gibt 0 zurück.

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

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

Im Folgenden finden Sie eine Lösung mit höchstwahrscheinlich schlechter Leistung, aber soliden Ergebnissen. Es handelt sich um eine aus der Implementierung von jQuery 1.12.4 und Michaels Antwort bestehende Vorrichtung mit einer zusätzlichen Prüfung für führende/nachgestellte Leerzeichen (da Michaels Version für Numerik mit führenden/nachgestellten 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 letztere Version hat jedoch zwei neue Variablen. Eine davon könnte man 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 nichts davon sehr viel getestet, mit anderen Mitteln, als manuell die wenigen Anwendungsfälle zu testen, die ich mit meiner aktuellen Situation treffen werde, was alles sehr üblich ist. Dies ist eine Situation "auf den Schultern der Giganten stehend".

Zitat:

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

ist nicht ganz richtig, wenn Sie nach führenden/nachfolgenden Leerzeichen suchen müssen - zum Beispiel, wenn eine bestimmte Anzahl von Ziffern erforderlich ist, und wenn Sie zum Beispiel '1111' und nicht '111' oder '111' für vielleicht ein _ erhalten müssen.PIN Eingabe.

Besser zu benutzen:

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

Ich mag die Einfachheit davon. 

Number.isNaN(Number(value))

Das obige ist normales Javascript, aber ich verwende dieses in Verbindung mit einem TypeScript typeguard zur intelligenten Typprüfung. Dies ist sehr nützlich für den TypeScript-Compiler, um korrekte Intellisense und keine Typfehler zu liefern.

TypeScript-Typenschutz

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

Angenommen, Sie haben eine Eigenschaft width, die number | string ist. Möglicherweise möchten Sie eine Logik erstellen, die darauf basiert, ob es sich um eine Zeichenfolge handelt.

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

Der Typeguard ist intelligent genug, um den Typ von width in der if-Anweisung auf NUR string zu beschränken. Dies erlaubt dem Compiler, width.endsWith(...) zu erlauben, was er nicht zulassen würde, wenn der Typ string | number war.

Sie können den Typeguard so nennen, wie Sie ihn wollen: isNotNumber, isNumber, isString, isNotString, aber ich denke, isString ist etwas mehrdeutig und schwerer zu lesen.

1
Simon_Weaver

Mein Versuch, etwas verwirrend zu sein, ist 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));           // 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
1
Endless

PFB die Arbeitslösung:

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

Wenn irgendjemand jemals so weit heruntergekommen ist, habe ich einige Zeit damit verbracht, zu versuchen, moment.js ( https://github.com/moment/moment ) zu patchen. Hier ist etwas, was ich davon genommen 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 die, mit der ich am meisten zu kämpfen habe:

isNumeric(new Number(1)) => false

Irgendwelche Vorschläge sind willkommen. :]

1
The Dembinski
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

if (isNumberCandidate(s)) {
  // use +s as a number
  +s ...
}
1
gvlax

Hier ist eine Hochleistungsversion (2,5 * 10 ^ 7 Iterationen/s bei 3,8 GHz Haswell) einer isNumber-Implementierung. Es funktioniert für jeden Testfall, den ich finden konnte (einschließlich Symbole):

var isNumber = (function () {
  var isIntegerTest = /^\d+$/;
  var isDigitArray = [!0, !0, !0, !0, !0, !0, !0, !0, !0, !0];
  function hasLeading0s (s) {
    return !(typeof s !== 'string' ||
    s.length < 2 ||
    s[0] !== '0' ||
    !isDigitArray[s[1]] ||
    isIntegerTest.test(s));
  }
  var isWhiteSpaceTest = /\s/;
  return function isNumber (s) {
    var t = typeof s;
    var n;
    if (t === 'number') {
      return (s <= 0) || (s > 0);
    } else if (t === 'string') {
      n = +s;
      return !((!(n <= 0) && !(n > 0)) || n === '0' || hasLeading0s(s) || !(n !== 0 || !(s === '' || isWhiteSpaceTest.test(s))));
    } else if (t === 'object') {
      return !(!(s instanceof Number) || ((n = +s), !(n <= 0) && !(n > 0)));
    }
    return false;
  };
})();
0
c7x43t

Sie können Typen verwenden, z. B. mit der Flusslibrar y, um eine statische Kompilierzeitprüfung zu erhalten. Natürlich nicht sehr 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!
0

In meiner Anwendung lassen wir nur a-z A-Z und 0-9 Zeichen zu. Ich fand die Antwort oben mit "string% 1 === 0" funktioniert, es sei denn, der String begann mit 0xnn (wie 0x10) und würde sie dann als numerisch zurückgeben, wenn wir es nicht wollten. Die folgende einfache Falle in meiner numerischen Prüfung scheint in unseren speziellen Fällen den Trick zu erfüllen. 

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 .

0
rwheadon

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 Fließkomma oder Ganzzahl, wenn das wichtig ist (+x vs. ~~x).

Der Artikel geht davon aus, dass die Variable string oder number ist und trim verfügbar/polyfilled ist. Es würde nicht schwer sein, es auch auf andere Typen auszuweiten. 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
}
0
Travis Parks

Verwenden Sie einfach isNaN(), dies konvertiert den String in eine number und wenn Sie eine gültige number erhalten, wird false... zurückgegeben.

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

Ich benutze die folgenden:

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

Sparen Sie sich die Kopfschmerzen, wenn Sie versuchen, 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 devs +, - oder Number () verwenden, um einen String-Wert in eine Zahl umzuwandeln (zum Beispiel, wenn Werte von Benutzereingaben, Regex-Übereinstimmungen, Parsern usw. zurückgegeben werden). Es gibt jedoch viele nicht intuitive Edge-Fälle, die unerwartete Ergebnisse liefern:

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

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)

0
Greg Woz

Hier ist ein Einzeiler, um zu prüfen, ob sNum einen gültigen numerischen Wert darstellt. Es wurde für eine Vielzahl von Eingaben getestet:

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

Verwenden Sie einfaches JavaScript:

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

Verwendung von Lodash:

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

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 Ihre speziellen Anforderungen zu erfüllen.

0
GoTo