Regular Expressions
Nützlicher Regex Showcase

Übereinstimmung mit einem Datum

Sie sollten sich daran erinnern, dass Regex dazu gedacht ist, ein Datum abzugleichen (oder nicht). Zu sagen, dass ein Datum gültig ist , ist ein viel komplizierterer Kampf, da es eine Menge Ausnahmebehandlung erfordert (siehe Bedingungen für das Schaltjahr ).

Beginnen wir mit dem Abgleichen des Monats (1 - 12) mit einer optionalen führenden 0:

0?[1-9]|1[0-2]

Um den Tag abzugleichen, auch mit einer optionalen führenden 0:

0?[1-9]|[12][0-9]|3[01]

Und um das Jahr abzugleichen (nehmen wir einfach an, dass der Bereich 1900 - 2999 reicht):

(?:19|20)[0-9]{2}

Das Trennzeichen kann ein Leerzeichen, ein Bindestrich, ein Schrägstrich, ein Leerzeichen usw. sein. Sie können alles hinzufügen, was Sie als Trennzeichen verwenden:

[-\\/ ]?

Jetzt verketten Sie das Ganze und erhalten:

(0?[1-9]|1[0-2])[-\\/ ]?(0?[1-9]|[12][0-9]|3[01])[-/ ]?(?:19|20)[0-9]{2} // MMDDYYYY
(0?[1-9]|[12][0-9]|3[01])[-\\/ ]?(0?[1-9]|1[0-2])[-/ ]?(?:19|20)[0-9]{2} // DDMMYYYY
(?:19|20)[0-9]{2}[-\\/ ]?(0?[1-9]|1[0-2])[-/ ]?(0?[1-9]|[12][0-9]|3[01]) // YYYYMMDD

Wenn Sie etwas pedantischer sein möchten, können Sie eine Rückwärtsreferenz verwenden, um sicherzustellen, dass die beiden Trennzeichen gleich sind:

(0?[1-9]|1[0-2])([-\\/ ]?)(0?[1-9]|[12][0-9]|3[01])\2(?:19|20)[0-9]{2} // MMDDYYYY
                                                 ^ refer to [-/ ]
(0?[1-9]|[12][0-9]|3[01])([-\\/ ]?)(0?[1-9]|1[0-2])\2(?:19|20)[0-9]{2} // DDMMYYYY
(?:19|20)[0-9]{2}([-\\/ ]?)(0?[1-9]|1[0-2])\2(0?[1-9]|[12][0-9]|3[01]) // YYYYMMDD

Übereinstimmung mit einer E-Mail-Adresse

Das Abgleichen einer E-Mail-Adresse innerhalb eines Strings ist eine schwierige Aufgabe, da die Spezifikation, die sie definiert, RFC2822 , komplex ist und die Implementierung als Regex schwierig gestaltet. Weitere Informationen dazu, warum es nicht ratsam ist, eine E-Mail mit einem regulären Ausdruck abzugleichen, finden Sie im Antipattern-Beispiel, wenn Sie keinen regulären Ausdruck für das Übereinstimmen von E-Mails verwenden . Der beste Hinweis, den Sie auf dieser Seite beachten sollten, ist die Verwendung einer von Experten geprüften und weit verbreiteten Bibliothek in Ihrer bevorzugten Sprache, um dies zu implementieren.

Bestätigen Sie ein E-Mail-Adressformat

Wenn Sie einen Eintrag schnell überprüfen müssen, um sicherzugehen, dass er wie eine E-Mail aussieht , sollten Sie ihn möglichst einfach halten:

^\S{1,}@\S{2,}\.\S{2,}$

Dieser reguläre Ausdruck überprüft, ob es sich bei der Mail-Adresse um eine nicht durch Leerzeichen getrennte Folge von Zeichen mit einer Länge von mehr als Eins handelt, gefolgt von einem @ , gefolgt von zwei Folgen von Nicht-Leerzeichen mit der Länge zwei oder mehr, die durch ein Zeichen getrennt werden . . Sie ist nicht perfekt und validiert möglicherweise ungültige Adressen (je nach Format). Vor allem aber werden gültige Adressen nicht ungültig.

Überprüfen Sie, ob die Adresse vorhanden ist

Die einzige zuverlässige Methode, um die Gültigkeit einer E-Mail zu überprüfen, besteht darin, auf ihre Existenz zu prüfen. Früher gab es den VRFY SMTP-Befehl, der für diesen Zweck entwickelt wurde, aber leider ist er nach dem Missbrauch durch Spammer jetzt nicht mehr verfügbar .

Die einzige Möglichkeit, um zu überprüfen, ob die Mail gültig ist und existiert, ist das Senden einer E-Mail an diese Adresse.

Riesige Regex-Alternativen

Es ist jedoch nicht unmöglich, eine Adressen-E-Mail mit einem regulären Ausdruck zu überprüfen. Das einzige Problem ist, dass je näher diese Ausdrücke sind, desto größer werden sie und als Folge sind sie unmöglich schwer zu lesen und zu pflegen. Im Folgenden finden Sie Beispiele für solche genaueren Regex, die in einigen Bibliotheken verwendet werden.

Re Die folgenden regulären Ausdrücke werden zu Dokumentations- und Lernzwecken angegeben. Das Kopieren in Ihren Code ist eine schlechte Idee. Verwenden Sie diese Bibliothek stattdessen direkt, sodass Sie sich auf Upstream-Code- und Peer-Entwickler verlassen können, um den Code für die E-Mail-Analyse auf dem neuesten Stand zu halten und zu pflegen.

Perl-Adressenanpassungsmodul

Die besten Beispiele für solche Regex sind in einigen Sprachen Standardbibliotheken. In der Perl-Bibliothek befindet sich beispielsweise ein Modul aus dem Modul RFC::RFC822::Address , das nach RFC so genau wie möglich zu sein versucht. Für Ihre Neugier finden Sie unter dieser URL eine Version dieser regulären Ausdrücke , die aus der Grammatik generiert wurde. Wenn Sie versucht sind, diese zu kopieren, fügen Sie sie hier ein. Hier ein Zitat des Regex-Autors:

" Ich pflege den regulären Ausdruck [linked] nicht. Es können Fehler darin enthalten sein, die bereits im Perl-Modul behoben wurden. "

NET-Adressenanpassungsmodul

Eine andere, kürzere Variante ist diejenige, die von der .Net-Standardbibliothek im EmailAddressAttribute Modul verwendet wird :

^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?$

Aber selbst wenn es kürzer ist, ist es immer noch zu groß, um lesbar und leicht zu pflegen.

Ruby-Adressenanpassungsmodul

In Ruby wird im Modul rfc822 eine Zusammensetzung von Regex verwendet, um eine Adresse zu finden. Dies ist eine nette Idee, denn wenn Fehler gefunden werden, ist es einfacher, den Regex-Teil zu lokalisieren, um ihn zu ändern und zu beheben.

Python-Adressenanpassungsmodul

Als Gegenbeispiel verwendet das Python- E-Mail-Parsing-Modul keinen regulären Ausdruck, sondern implementiert es mit einem Parser.

Übereinstimmung mit einer Telefonnummer

So passen Sie einen Präfixcode an (a + oder (00), dann eine Zahl von 1 bis 1939 mit optionalem Leerzeichen):
^{Es wird nicht nach einem gültigen Präfix gesucht, sondern nach einem Präfix. Siehe die vollständige Liste der Präfixe}

(?:00|\+)?[0-9]{4}

Da die Länge der gesamten Telefonnummer höchstens 15 beträgt, können wir bis zu 14 Ziffern suchen:
^{Für das Präfix wird mindestens eine Ziffer ausgegeben}

[0-9]{1,14}

Die Zahlen können Leerzeichen, Punkte oder Bindestriche enthalten und können mit 2 oder 3 gruppiert werden.

(?:[ .-][0-9]{3}){1,5}

Mit dem optionalen Präfix:

(?:(?:00|\+)?[0-9]{4})?(?:[ .-][0-9]{3}){1,5}

Wenn Sie ein bestimmtes Länderformat verwenden möchten, können Sie diese Suchabfrage verwenden und das Land hinzufügen. Die Frage wurde sicherlich bereits gestellt.

Stimmen Sie eine IP-Adresse ab

IPv4

Um das IPv4-Adressformat abzugleichen, müssen Sie die Nummern [0-9]{1,3} dreimal {3} getrennt durch Punkte \. , überprüfen \. und endet mit einer anderen Nummer.

^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$

Dieser reguläre Ausdruck ist zu einfach. Wenn Sie möchten, dass er genau ist, müssen Sie überprüfen, ob die Zahlen zwischen 0 und 255 , wobei der Regex oben in einer beliebigen Position 444 akzeptiert. Sie möchten auf 250-255 mit 25[0-5] oder einem anderen Wert 200 2[0-4][0-9] oder einem Wert von 100 oder weniger mit [01]?[0-9][0-9] prüfen. [01]?[0-9][0-9] . Sie möchten prüfen, ob ein Punkt \. folgt \. dreimal {3} und dann einmal ohne Punkt.

^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$

IPv6

IPv6 - Adressen haben die Form von 8 16-Bit - Worten hex begrenzt mit dem Doppelpunkt ( : ) Charakter. In diesem Fall prüfen wir nach 7 Wörtern, gefolgt von Doppelpunkten, gefolgt von einem, das nicht ist. Wenn ein Wort führende Nullen hat, werden diese möglicherweise abgeschnitten. Dies bedeutet, dass jedes Wort zwischen 1 und 4 Hexadezimalstellen enthalten kann.

^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$

Dies reicht jedoch nicht aus. Da IPv6-Adressen ziemlich "wortreich" werden können, gibt der Standard an, dass nur Zero-Words durch :: ersetzt werden können. Dies darf nur einmal in einer Adresse (für 1 bis 7 aufeinanderfolgende Wörter) erfolgen, da dies ansonsten unbestimmt wäre. Dies führt zu einer Reihe von (eher unangenehmen) Variationen:

^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}$
^[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}$
^[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,4}[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,2}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,3}[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,3}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,2}[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,4}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:)?[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}::[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}::$

Wenn Sie nun alles zusammenstellen (alternierend), erhalten Sie:

^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|
^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}$|
^[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}$|
^[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,4}[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,2}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,3}[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,3}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,2}[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,4}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:)?[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}::[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}::$

Stellen Sie sicher, dass Sie es in einem mehrzeiligen Modus und mit vielen Kommentaren aufschreiben, damit derjenige, der unweigerlich herauszufinden versucht, was dies bedeutet, nicht mit einem stumpfen Gegenstand hinter Ihnen her kommt.

Bestätigen Sie eine 12- und 24-Stunden-Zeichenfolge

Für ein 12-Stunden-Format können Sie Folgendes verwenden:

^(?:0?[0-9]|1[0-2])[-:][0-5][0-9]\s*[ap]m$

Woher

• (?:0?[0-9]|1[0-2]) ist die Stunde
• [-:] ist das Trennzeichen, das an Ihre Bedürfnisse angepasst werden kann
• [0-5][0-9] ist die Minute
• \s*[ap]m folgt einer beliebigen Anzahl von Whitespace-Zeichen und am oder pm

Wenn Sie die Sekunden brauchen:

^(?:0?[0-9]|1[0-2])[-:][0-5][0-9][-:][0-5][0-9]\s*[ap]m$

Für ein 24-Stunden-Format:

^(?:[01][0-9]|2[0-3])[-:h][0-5][0-9]$

Woher:

• (?:[01][0-9]|2[0-3]) ist die Stunde
• [-:h] das Trennzeichen, das an Ihre Bedürfnisse angepasst werden kann
• [0-5][0-9] ist die Minute

Mit den Sekunden:

^(?:[01][0-9]|2[0-3])[-:h][0-5][0-9][-:m][0-5][0-9]$

Wobei [-:m] ein zweites Trennzeichen ist, wobei h für Stunden durch ein m für Minuten ersetzt wird und [0-5][0-9] das zweite ist.

Entsprechende britische Postleitzahl

Regex für Postleitzahlen in Großbritannien

Das Format ist wie folgt, wobei A einen Buchstaben und 9 eine Ziffer bedeutet:

(GIR 0AA)|((([A-Z-[QVX]][0-9][0-9]?)|(([A-Z-[QVX]][A-Z-[IJZ]][0-9][0-9]?)|(([A-Z-[QVX]][0-9][A-HJKPSTUW])|([A-Z-[QVX]][A-Z-[IJZ]][0-9][ABEHMNPRVWXY])))) [0-9][A-Z-[CIKMOV]]{2})

Wo erster Teil:

 (GIR 0AA)|((([A-Z-[QVX]][0-9][0-9]?)|(([A-Z-[QVX]][A-Z-[IJZ]][0-9][0-9]?)|(([A-Z-[QVX]][0-9][A-HJKPSTUW])|([A-Z-[QVX]][A-Z-[IJZ]][0-9][ABEHMNPRVWXY]))))

Zweite:

[0-9][A-Z-[CIKMOV]]{2})