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

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

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
}

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

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

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

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

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.

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

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

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.

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

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)

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.

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)

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.

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

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

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

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

PFB die Arbeitslösung:

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

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'

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
}

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

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.

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.

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!

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

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

Ich benutze folgendes:

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