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




auf match (16)

var reg = /^\d+$/;

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

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?


Wie Sie sagten, möchten Sie Hash nur Zahlen enthalten.

var reg = new RegExp('^[0-9]+$');

oder

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

\d und [0-9] bedeuten beide dasselbe. Das verwendete + bedeutet, dass nach einem oder mehreren Vorkommen von [0-9] gesucht wird.


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.


Nummer nur Regex ( aktualisiert )

 var reg = new RegExp('[^0-9]','g');

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*$/

Warum nicht etwas verwenden wie:

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

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


var pattern = /[0-9!"£$%^&*()_+-=]/;

Dies versucht einige Szenarien zu vermeiden, nur für den Fall:

Wenn Sie alle Puffer überschreiben, wird möglicherweise die ursprüngliche Zeichenfolge übergeben. Langsamkeit oder Kuriositäten, verursacht durch denormale Zahlen wie 1E-323 . Infinity übergeben, wenn eine endliche Zahl erwartet wird (versuchen Sie 1E309 oder -1E309 ).


Wenn Sie bei der Eingabe andere Zeichen herausfiltern und nur Zahlen im Eingabefeld anzeigen möchten, können Sie den Wert des Feldes in der Tastenkombination ersetzen:

    var yourInput = jQuery('#input-field');
    yourInput.keyup(function() {
        yourInput.val((yourInput.val().replace(/[^\d]/g,'')))
    })   

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+$/;

var validation = {
    isEmailAddress:function(str) {
        var pattern =/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
        return pattern.test(str);  // returns a boolean
    },
    isNotEmpty:function (str) {
        var pattern =/\S+/;
        return pattern.test(str);  // returns a boolean
    },
    isNumber:function(str) {
        var pattern = /^\d+$/;
        return pattern.test(str);  // returns a boolean
    },
    isSame:function(str1,str2){
        return str1 === str2;
    }
};   

alert(validation.isNotEmpty("dff"));
alert(validation.isNumber(44));
alert(validation.isEmailAddress("[email protected]"));
alert(validation.isSame("sf","sf"));

Wenn Sie nur positive ganze Zahlen benötigen und keine führenden Nullen benötigen (zB "0001234" oder "00"):

var reg = /^(?:[1-9]\d*|\d)$/;

/^[\+\-]?\d*\.?\d+(?:[Ee][\+\-]?\d+)?$/

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

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

^[0-9]$ 

... ist ein regulärer Ausdruck, der einer einzelnen Ziffer entspricht, also gibt 1 wahr zurück, aber 123 gibt false zurück.

Wenn Sie den * Quantor hinzufügen,

^[0-9]*$

Der Ausdruck passt beliebig lange Ziffernfolgen an und 123 gibt true zurück. (123f wird immer noch falsch zurückgegeben).

Beachten Sie, dass ein leerer String normalerweise eine Ziffernfolge mit einer Länge von 0 ist. Daher wird er mit ^ [0-9] * $ als wahr zurückgegeben. Wenn Sie nur Zeichenfolgen mit 1 oder mehr Ziffern akzeptieren möchten, verwenden Sie + anstelle von *.

^[0-9]+$

Wie viele andere bereits festgestellt haben, gibt es mehr als ein paar Möglichkeiten, dies zu erreichen, aber ich hielt es für angebracht, darauf hinzuweisen, dass der Code in der ursprünglichen Frage nur ein einziges zusätzliches Zeichen benötigt, um wie beabsichtigt zu arbeiten.


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

Sie könnten auch mit Regexs gehen:

if((/^\s*$/).test(str)) { }

Überprüft, ob Zeichenfolgen leer oder mit Leerzeichen gefüllt sind.





javascript regex