javascript string - Regex, um zu prüfen, ob eine Zeichenfolge nur Zahlen enthält




9 Answers

var reg = /^\d+$/;

Sollte es tun. Das Original entspricht allem, was aus genau einer Ziffer besteht.

auf match
hash = window.location.hash.substr(1);
var reg = new RegExp('^[0-9]$');
console.log(reg.test(hash));

Ich werde sowohl bei "123" als auch "123f" falsch. Ich würde gerne überprüfen, ob der Hash nur Zahlen enthält. Habe ich etwas verpasst?




Dieser wird auch für signierte und float Zahlen oder leere Zeichenfolgen erlauben:

var reg = /^-?\d*\.?\d*$/

Wenn Sie nicht zulassen möchten, dass die Zeichenfolge leer ist, verwenden Sie diese:

var reg = /^-?\d+\.?\d*$/



Das ist extremer Overkill für deinen Zweck, aber hier ist, was ich benutze:

var numberReSnippet = "(?:NaN|-?(?:(?:\\d+|\\d*\\.\\d+)(?:[E|e][+|-]?\\d+)?|Infinity))";
var matchOnlyNumberRe = new RegExp("^("+ numberReSnippet + ")$");

Nach meinem Wissen entspricht dies allen Variationen von Zahlen, die Ihnen Java und JavaScript jemals liefern werden, einschließlich "-Infinity", "1e-24" und "NaN". Es stimmt auch mit Zahlen überein, die Sie eingeben könnten, wie beispielsweise "-.5".

Wie geschrieben, ist reSnippet so konzipiert, dass es in andere reguläre Ausdrücke eingefügt wird, sodass Sie Zahlen extrahieren (oder vermeiden) können. Trotz aller Klammern enthält es keine einfangenden Gruppen. Daher stimmt "matchOnlyNumberRe" nur mit Zeichenfolgen überein, die Zahlen sind, und hat eine Erfassungsgruppe für die gesamte Zeichenfolge.

Hier sind die Jasmine-Tests, damit Sie sehen können, was es tut und was nicht:

describe("Number Regex", function() {
    var re = new RegExp("^("+ numberReSnippet + ")$");
    it("Matches Java and JavaScript numbers", function() {
        expect(re.test(         "1")).toBe(true);
        expect(re.test(       "0.2")).toBe(true);
        expect(re.test(     "0.4E4")).toBe(true);  // Java-style
        expect(re.test(       "-55")).toBe(true);
        expect(re.test(      "-0.6")).toBe(true);
        expect(re.test(  "-0.77E77")).toBe(true);
        expect(re.test(      "88E8")).toBe(true);
        expect(re.test(       "NaN")).toBe(true);
        expect(re.test(  "Infinity")).toBe(true);
        expect(re.test( "-Infinity")).toBe(true);
        expect(re.test(     "1e+24")).toBe(true);  // JavaScript-style
    });
    it("Matches fractions with a leading decimal point", function() {
        expect(re.test(        ".3")).toBe(true);
        expect(re.test(       "-.3")).toBe(true);
        expect(re.test(     ".3e-4")).toBe(true);
    });
    it("Doesn't match non-numbers", function() {
        expect(re.test(         ".")).toBe(false);
        expect(re.test(        "9.")).toBe(false);
        expect(re.test(          "")).toBe(false);
        expect(re.test(         "E")).toBe(false);
        expect(re.test(       "e24")).toBe(false);
        expect(re.test(   "1e+24.5")).toBe(false);
        expect(re.test("-.Infinity")).toBe(false);
    });
});



Diese Funktion prüft, ob die Eingabe im klassischen Sinn numerisch ist, da erwartet wird, dass eine normale Nummernerkennungsfunktion funktioniert.

Es ist ein Test, den man beispielsweise für die HTML-Formulareingabe verwenden kann.

Es umgeht alle JS Folklore, wie tipeof (NaN) = Nummer, Parseint ('1 Kg') = 1, booleans in Zahlen und dergleichen gezwungen.

Dies geschieht, indem das Argument als String dargestellt wird und diese Zeichenkette gegen eine Regex wie die von @ codename- geprüft wird, aber Einträge wie 5. und .5 erlaubt werden

function isANumber( n ) {
    var numStr = /^-?(\d+\.?\d*)$|(\d*\.?\d+)$/;
    return numStr.test( n.toString() );
}

not numeric:
Logger.log( 'isANumber( "aaa" ): ' + isANumber( 'aaa' ) );
Logger.log( 'isANumber( "" ): ' + isANumber( '' ) );
Logger.log( 'isANumber( "lkjh" ): ' + isANumber( 'lkjh' ) );
Logger.log( 'isANumber( 0/0 ): ' + isANumber( 0 / 0 ) );
Logger.log( 'isANumber( 1/0 ): ' + isANumber( 1 / 0 ) );
Logger.log( 'isANumber( "1Kg" ): ' + isANumber( '1Kg' ) );
Logger.log( 'isANumber( "1 Kg" ): ' + isANumber( '1 Kg' ) );
Logger.log( 'isANumber( false ): ' + isANumber( false ) );
Logger.log( 'isANumber( true ): ' + isANumber( true ) );

numeric:
Logger.log( 'isANumber( "0" ): ' + isANumber( '0' ) );
Logger.log( 'isANumber( "12.5" ): ' + isANumber( '12.5' ) );
Logger.log( 'isANumber( ".5" ): ' + isANumber( '.5' ) );
Logger.log( 'isANumber( "5." ): ' + isANumber( '5.' ) );
Logger.log( 'isANumber( "-5" ): ' + isANumber( '-5' ) );
Logger.log( 'isANumber( "-5." ): ' + isANumber( '-5.' ) );
Logger.log( 'isANumber( "-.5" ): ' + isANumber( '-5.' ) );
Logger.log( 'isANumber( "1234567890" ): ' + isANumber( '1234567890' ));

Erklärung der Regex:

/^-?(\d+\.?\d*)$|(\d*\.?\d+)$/  

Das erste "^" und das letzte "$" stimmen mit dem Anfang und dem Ende des Strings überein, um sicherzustellen, dass der Check den gesamten String umfasst. Das "-?" Teil ist das Minuszeichen mit dem "?" Multiplikator, der null oder eine Instanz davon erlaubt.

Dann gibt es zwei ähnliche Gruppen, die durch Klammern voneinander getrennt sind. Die Zeichenfolge muss einer dieser Gruppen entsprechen. Der erste entspricht Zahlen wie 5. und der zweite .5

Die erste Gruppe ist

\d+\.?\d*

Das "\ d +" passt ein oder mehrere Male zu einer Ziffer (\ d).
Das "\.?" ist der Dezimalpunkt (entkommt mit "\", um es von seiner Magie zu befreien), null oder ein Mal.

Der letzte Teil "\ d *" ist wieder eine Ziffer, null oder mehrmals.
Alle Teile sind optional, aber die erste Ziffer, so dass diese Gruppe Zahlen wie 5. und nicht .5, die von der anderen Hälfte übereinstimmen, entspricht.




Du brauchst das * also sagt es "null oder mehr des vorherigen Charakters" und das sollte es tun:

var reg = new RegExp('^\\d*$');



Warum nicht etwas verwenden wie:

$.isNumeric($(input).val())

Wird jquery getestet und der häufigste Fall wird überprüft




Ich sehe, Sie haben bereits eine Menge Antworten erhalten, aber wenn Sie nach einem regulären Ausdruck suchen, der Integer und Gleitkommazahlen abgleichen kann, wird dieser für Sie arbeiten:

var reg = /^-?\d*\.?\d+$/;



Wenn Sie die Zahlen mit vorzeichenbehafteten Werten abgleichen möchten, können Sie Folgendes verwenden:

var reg = new RegExp('^(\-?|\+?)\d*$');

Es wird die Zahlen des Formats validieren: +1, -1, 1.




Benutze das:

const pattern = new RegExp(/^[+-]?\d+(\.\d+)?([Ee][+-]?\d+)?$/g);



Related

javascript regex