REGEXTESTEN Reguläre Ausdrücke mit vielen Beispielen
Hier auf dieser Seite werde ich Euch viele Beispiele für reguläre Ausdrücke geben die Ihr ganz leicht mit Excel 365 nachbilden könnt.
Reguläre Ausdrücke sind ein mächtiges Werkzeug um sehr detaillierte Vergleichsmuster zu erstellen.
Dabei werde ich mit einfachen Mustern anfangen die zum Ende hin immer komplexer werden.
Auf weiteren Seiten von mir findet Ihr übrigens REGEXERSETZEN oder REGEXEXTRAHIEREN falls Ihr Euch dafür interessiert.
Um damit selbst ein wenig herumexperimentieren zu können, könnt Ihr Euch gerne die Tabellen Vorlage hier direkt ganz einfach herunterladen. Die Vorlage enthält die bereits die Formel REGEXTESTEN und zusätzlich die bedingte Formatierung, um Zellen zu markieren die WAHR zurück liefern.
Somit könnt Ihr auch einfach Eure eigenen Muster ausprobieren. Oben in Zelle A1 stellt Ihr Euch das Muster zusammen und unten im Bereich A3 bis A8 könnt Ihr Daten eintragen um das Muster zu testen.
Auf der rechten Seite wird dann WAHR oder FALSCH zurückgegeben und die Zellen mit WAHR werden farbig markiert.
HIER DER DOWNLOAD der Vorlage:
Download Vorlage-REGEXTESTEN-DOWNLOAD.xlsx
Download Vorlage-REGEXTESTEN-DOWNLOAD.xlsx als ZIP Datei
Ein Video was zeigt wie ich die Tabelle aufgebaut habe und einfache Grundlagen im Umgang mit regulären Ausdrücken findet Ihr ganz unten.
[ Zum Video ]
Ihr könnt gerne in die Kommentare Eure eigenen Muster eintragen, Wünsche zu neuen Mustern äußern und Euch bei Fragen natürlich auch gerne gegenseitig helfen. Ich denke das ganze Thema ist zwar etwas kompliziert aber macht auch richtig Spaß.
Tipp: Deckt die Spalte mit den Antworten (WAHR/FALSCH) ab und überlegt, welche Antwort Ihr erwarten würdest. So könnt Ihr Euer Wissen testen! 🙂
Funktionsaufbau von REGEXTESTEN
Die Funktion REGEXTESTEN prüft, ob der angegebene Text mit dem regulären Ausdruck übereinstimmt. Sie gibt WAHR zurück, wenn eine Übereinstimmung gefunden wurde, und FALSCH, wenn keine Übereinstimmung vorliegt.
REGEXTESTEN(Text; Muster; [Groß-/Kleinschreibung])
Parameter:
- Text
Der Text, der auf das Muster überprüft werden soll. Dies kann ein direkter Textstring (in Anführungszeichen) oder ein Verweis auf eine Zelle sein, die einen Text enthält. - Muster
Der reguläre Ausdruck, der im Text gesucht wird. Es wird überprüft, ob der Text mit dem Muster übereinstimmt. Es wird der standardisierte RegEx-Syntax PCRE2 verwendet. - Groß-/Kleinschreibung (optional)
Legt fest, ob bei der Musterprüfung die Groß-/Kleinschreibung beachtet wird. Standardmäßig wird die Groß-/Kleinschreibung beachtet (0oderFALSCH).
0FALSCH(Standard): Beachtet die Groß-/Kleinschreibung.
1oderWAHR: Ignoriert die Groß-/Kleinschreibung.
Metazeichen
Hier ist eine Auflistung von vielen Metazeichen die Euch auf dieser Seite begegnen könnten. Um das etwas besser zu verstehen gibt es natürlich auch eine kurze Beschreibung dazu 🙂
| Metazeichen | Bedeutung | Beispiel |
|---|---|---|
. |
Beliebiges Zeichen (außer Zeilenumbrüche) | a.c findet "abc", "axc", aber nicht "ac" |
\d |
Beliebige Ziffer (0–9) | \d+ findet "12345" |
\D |
Kein Ziffernzeichen | \D+ findet "abc" |
\w |
Alphanumerisches Zeichen oder Unterstrich | \w+ findet "abc_123" |
\W |
Kein alphanumerisches Zeichen | \W+ findet "!@#" |
\s |
Beliebiges Leerzeichen (auch Tab) | a\s+b findet "a b" |
\S |
Kein Leerzeichen | \S+ findet "abc123" |
^ |
Anfang der Zeichenkette | ^abc findet "abc" am Anfang |
$ |
Ende der Zeichenkette | abc$ findet "abc" am Ende |
* |
0 oder mehr Wiederholungen | ab*c findet "ac", "abc", "abbc" |
+ |
1 oder mehr Wiederholungen | ab+c findet "abc", "abbc", aber nicht "ac" |
? |
0 oder 1 Wiederholung | ab?c findet "ac", "abc" |
{n} |
Genau n Wiederholungen | a{3} findet "aaa" |
{n,} |
Mindestens n Wiederholungen | a{2,} findet "aa", "aaa", "aaaa" |
{n,m} |
Zwischen n und m Wiederholungen | a{2,4} findet "aa", "aaa", "aaaa" |
| |
Alternativen (oder) | a|b findet "a" oder "b" |
( ) |
Gruppierung | (ab)+ findet "abab" |
[ ] |
Zeichenklasse | [abc] findet "a", "b", "c" |
[^ ] |
Negierte Zeichenklasse | [^abc] findet alles außer "a", "b", "c" |
\b |
Wortgrenze | \bword\b findet "word", aber nicht "sword" |
(?= ) |
Lookahead (Prüfen ohne Matchen) | abc(?=def) findet "abc", wenn es von "def" gefolgt wird |
(?! ) |
Negativer Lookahead | abc(?!def) findet "abc", wenn es nicht von "def" gefolgt wird |
Maskierung von Metazeichen in der Excel-Funktion REGEXTESTEN
Ihr könnt Zeichen mit einem Backslash \ maskieren um zum Beispiel nach diesen Zeichen zu suchen.
| Zeichen | Bedeutung (unmaskiert) | Maskierung erforderlich? |
|---|---|---|
| \\ | Escape-Zeichen (zum Maskieren anderer Zeichen) | Ja, wenn ihr einen Backslash suchen möchtet |
| . | Beliebiges Zeichen (außer Zeilenumbruch) | Ja, wenn ihr einen Punkt suchen möchtet |
| ^ | Anfang eines Strings oder einer Zeile | Ja, wenn ihr ein `^` suchen möchtet |
| $ | Ende eines Strings oder einer Zeile | Ja, wenn ihr ein `$` suchen möchtet |
| * | Wiederholung (0 oder mehr) | Ja, wenn ihr ein `*` suchen möchtet |
| + | Wiederholung (1 oder mehr) | Ja, wenn ihr ein `+` suchen möchtet |
| ? | Optional (0 oder 1) | Ja, wenn ihr ein `?` suchen möchtet |
| { } | Quantifizierer (z. B. `{1,3}`) | Ja, wenn ihr `{` oder `}` suchen möchtet |
| ( ) | Gruppierung oder Capturing Groups | Ja, wenn ihr `(` oder `)` suchen möchtet |
| [ ] | Zeichenklassen | Ja, wenn ihr `[` oder `]` suchen möchtet |
| | | ODER-Bedingung | Ja, wenn ihr ein `|` suchen möchtet |
| / | Schrägstrich (kein spezielles Zeichen in Excel-RegEx) | Nein |
| – | Spanne in Zeichenklassen (z. B. `[a-z]`) | Ja, innerhalb von Zeichenklassen (wenn zwischen Zeichen) |
| ` | Backtick (keine spezielle Bedeutung) | Nein |
Einfache Beispiele für die Excel Funktion REGEXTESTEN
Muster: ^.{8,12}$
Beschreibung: Findet Zeichenketten mit mindestens 8 und maximal 12 Zeichen.
Der Punkt steht dabei für jedes beliebe Zeichen. Hier habt Ihr auch den ^ Anfangs-Anker und $ End-Anker. Das zeigt Euch das dieses Muster von Anfang bis Ende des Textes stimmen muss.
| A | B | |
|---|---|---|
| 1 | ^.{8,12}$ | |
| 2 | ||
| 3 | Hier kommt langer Text | FALSCH |
| 4 | Hier kommt Text | FALSCH |
| 5 | Hier kommt | WAHR |
| 6 | Hier 123 | WAHR |
| 7 | Wenig | FALSCH |
Muster: ^\d{4}$
Beschreibung: Findet genau 4-stellige Zahlen (z. B. PIN-Codes oder kurze IDs).
| A | B | |
|---|---|---|
| 1 | ^\d{4}$ | |
| 2 | ||
| 3 | 1 | FALSCH |
| 4 | 1234 | WAHR |
| 5 | ABCD | FALSCH |
| 6 | 12AB | FALSCH |
| 7 | 1111 | WAHR |
Muster: ^\d$
Beschreibung: Findet genau eine einzelne Ziffer (0 bis 9).
| A | B | |
|---|---|---|
| 1 | ^\d$ | |
| 2 | ||
| 3 | Text | FALSCH |
| 4 | 2 | WAHR |
| 5 | Text mit der Zahl 234 | FALSCH |
| 6 | 9 | WAHR |
| 7 | 1221 | FALSCH |
Muster: ^[1-9]\d{4}$
Beschreibung: Findet fünfstellige Zahlen, die nicht mit einer 0 beginnen (z. B. deutsche Postleitzahlen).
| A | B | |
|---|---|---|
| 1 | ^[1-9]\d{4}$ | |
| 2 | ||
| 3 | 12345 | WAHR |
| 4 | 123456 | FALSCH |
| 5 | 01234 | FALSCH |
| 6 | Text | FALSCH |
| 7 | 1.2. | FALSCH |
Muster: ^-?\d+(,\d+)?$
Beschreibung: Findet positive oder negative Dezimalzahlen.
| A | B | |
|---|---|---|
| 1 | ^-?\d+(,\d+)?$ | |
| 2 | ||
| 3 | 10000,00 | WAHR |
| 4 | -1000,00 | WAHR |
| 5 | 455,99 | WAHR |
| 6 | 10^4 | FALSCH |
| 7 | Text | FALSCH |
Muster: ^-?\d+,\d+$
Beschreibung: Überprüft Dezimalzahlen mit mindestens einer Ziffer vor und nach dem Komma.
| A | B | |
|---|---|---|
| 1 | ^-?\d+,\d+$ | |
| 2 | ||
| 3 | 111,2 | WAHR |
| 4 | 44,123 | WAHR |
| 5 | 12345678 | FALSCH |
| 6 | 100 | FALSCH |
| 7 | 100,4 | WAHR |
Muster: ^[a-zA-Z0-9]+$
Beschreibung: Überprüft Zeichenketten, die nur Buchstaben und Zahlen enthalten.
Achtet darauf dass hier kein ÄÖÜäöüß mit eingetragen wurde 😉
Wenn Ihr das zusätzlich wollt müsst Ihr das so schreiben:
Muster: ^[a-zA-Z0-9ÄÖÜäöüß]+$
| A | B | |
|---|---|---|
| 1 | ^[a-zA-Z0-9]+$ | |
| 2 | ||
| 3 | Test123 | WAHR |
| 4 | Test@123 | FALSCH |
| 5 | Zusammenhaengend | WAHR |
| 6 | Zusammenängend | FALSCH |
| 7 | Wenig | WAHR |
Muster: ^.+.(jpg|png|gif|bmp)$
Beschreibung: Überprüft Dateinamen mit den Endungen .jpg, .png, .gif oder .bmp.
| A | B | |
|---|---|---|
| 1 | ^.+\.(jpg|png|gif|bmp)$ | |
| 2 | ||
| 3 | Dateiname.tmp | FALSCH |
| 4 | Dateiname.jpg | WAHR |
| 5 | Dateiname.xml | FALSCH |
| 6 | Dateiname.htp | FALSCH |
| 7 | Dateiname.png | WAHR |
Muster: ^R[a-zA-Z]*$
Beschreibung: Findet Wörter, die mit "R" beginnen, gefolgt von beliebigen Buchstaben (Groß- oder Kleinschreibung).
Achtet darauf dass hier ebenfalls kein ÄÖÜäöüß mit eingetragen wurde 😉
Wollt Ihr das ebenfalls müsst Ihr die Formel folgendermaßen umschreiben:
^R[a-zA-ZÄÖÜäöüß]*$
| A | B | |
|---|---|---|
| 1 | ^R[a-zA-Z]*$ | |
| 2 | ||
| 3 | Maus | FALSCH |
| 4 | Rabe | WAHR |
| 5 | Taube | FALSCH |
| 6 | Raupe | WAHR |
| 7 | Rübe | FALSCH |
Muster: ^[a-z]$
Beschreibung: Findet genau einen kleinen Buchstaben (a bis z).
Falls Ihr auch äöüß braucht, dann muss die Formel so aussehen:
^[a-zäöüß]$
| A | B | |
|---|---|---|
| 1 | ^[a-z]$ | |
| 2 | ||
| 3 | Text | FALSCH |
| 4 | a | WAHR |
| 5 | Text mit der Zahl 234 | FALSCH |
| 6 | s | WAHR |
| 7 | 1221 | FALSCH |
Muster: ^[a-z]+$
Beschreibung: Findet Zeichenketten, die ausschließlich aus Kleinbuchstaben bestehen.
Falls Ihr auch äöüß braucht, dann muss die Formel so aussehen:
^[a-zäöüß]+$
| A | B | |
|---|---|---|
| 1 | ^[a-z]+$ | |
| 2 | ||
| 3 | a | WAHR |
| 4 | auch | WAHR |
| 5 | nicht mehr | FALSCH |
| 6 | 1234 | FALSCH |
| 7 | AB | FALSCH |
Muster: ^[A-Z]$
Beschreibung: Findet genau einen großen Buchstaben (A bis Z).
Falls Ihr auch ÄÖÜ braucht, dann muss die Formel so aussehen:
^[A-ZÄÖÜ]$
| A | B | |
|---|---|---|
| 1 | ^[A-Z]$ | |
| 2 | ||
| 3 | Text | FALSCH |
| 4 | K | WAHR |
| 5 | Hier kommt etwas Text | FALSCH |
| 6 | M | WAHR |
| 7 | 3335 T 487 | FALSCH |
Muster: ^[a-zA-Z]$
Beschreibung: Findet genau einen Buchstaben, unabhängig von Groß- oder Kleinschreibung.
| A | B | |
|---|---|---|
| 1 | ^[a-zA-Z]$ | |
| 2 | ||
| 3 | Eins | FALSCH |
| 4 | K | WAHR |
| 5 | a | WAHR |
| 6 | 555 T 8899 | FALSCH |
| 7 | 3335 T 487 | FALSCH |
———————————————————————————————-
Muster: ^[A-Z]+(-[A-Z]+)+$
Beschreibung: Überprüft Zeichenketten, die nur aus Großbuchstaben bestehen und durch Bindestriche getrennt sind.
| A | B | |
|---|---|---|
| 1 | ^[A-Z]+(-[A-Z]+)+$ | |
| 2 | ||
| 3 | klein | FALSCH |
| 4 | GROSS | FALSCH |
| 5 | GROSS-GROSS | WAHR |
| 6 | GROSS-klein | FALSCH |
| 7 | GROSS-1234 | FALSCH |
Muster: ^[A-Z][a-z]+( [A-Z][a-z]+)*$
Beschreibung: Überprüft Namen mit Groß-/Kleinschreibung und optionalen Leerzeichen.
| A | B | |
|---|---|---|
| 1 | ^[A-Z][a-z]+( [A-Z][a-z]+)*$ | |
| 2 | ||
| 3 | Max Mustermann | WAHR |
| 4 | max mustermann | FALSCH |
| 5 | Max mustermann | FALSCH |
| 6 | max Mustermann | FALSCH |
| 7 | Max | WAHR |
Muster: ^\w+$
Beschreibung: Findet Zeichenketten, die nur aus Buchstaben, Ziffern oder Unterstrichen bestehen.
| A | B | |
|---|---|---|
| 1 | ^\w+$ | |
| 2 | ||
| 3 | Eins | WAHR |
| 4 | Text12345 | WAHR |
| 5 | Hier kommt Text | FALSCH |
| 6 | Hier_kommt_Text | WAHR |
| 7 | Hier-kommt-Text | FALSCH |
Muster: ^\w{8,}$
Beschreibung: Findet Zeichenketten mit mindestens 8 Zeichen, die Buchstaben, Ziffern oder Unterstriche enthalten.
| A | B | |
|---|---|---|
| 1 | ^\w{8,}$ | |
| 2 | ||
| 3 | Mindestens | WAHR |
| 4 | 8 | FALSCH |
| 5 | Zeichen | FALSCH |
| 6 | notwendig | WAHR |
| 7 | 12345678 | WAHR |
Muster: ^\d{9}[0-9X]$
Beschreibung: Überprüft ISBN-10-Nummern, bei denen die letzte Stelle eine Ziffer oder ein "X" sein kann.
| A | B | |
|---|---|---|
| 1 | ^\d{9}[0-9X]$ | |
| 2 | ||
| 3 | 123456789X | WAHR |
| 4 | 1234567890 | WAHR |
| 5 | 12345678 | FALSCH |
| 6 | ABC12345678 | FALSCH |
| 7 | 555555555X | WAHR |
Muster: \d+
Beschreibung: Findet eine oder mehrere Ziffern.
| A | B | |
|---|---|---|
| 1 | \d+ | |
| 2 | ||
| 3 | Hier Text und die Zahl 12345 | WAHR |
| 4 | Hier nur Text | FALSCH |
| 5 | Das ist eine 5 | WAHR |
| 6 | Abc Def | FALSCH |
| 7 | 442 Abc | WAHR |
Muster: ^[a-zA-Z]+$
Beschreibung: Findet Zeichenketten, die ausschließlich aus einem oder mehreren Groß- oder Kleinbuchstaben bestehen.
Hinweis: Die Zeichen ä, ö, ü (und andere wie ß) sind nicht standardmäßig in [a-zA-Z] enthalten.
| A | B | |
|---|---|---|
| 1 | ^[a-zA-Z]+$ | |
| 2 | ||
| 3 | Wort | WAHR |
| 4 | Hier kommt Text mit Leerzeichen | FALSCH |
| 5 | Zusammen | WAHR |
| 6 | 1111 | FALSCH |
| 7 | 11111 33333 | FALSCH |
Muster: ^[A-Z][a-z]+$
Beschreibung: Findet Wörter, die mit einem Großbuchstaben beginnen und danach nur Kleinbuchstaben enthalten.
| A | B | |
|---|---|---|
| 1 | ^[A-Z][a-z]+$ | |
| 2 | ||
| 3 | Richtig | WAHR |
| 4 | nicht richtig | FALSCH |
| 5 | Ist das hier richtig? | FALSCH |
| 6 | Super | WAHR |
| 7 | nicht gut | FALSCH |
Muster: ^[a-zA-ZäöüÄÖÜß]+$
Beschreibung: Findet Zeichenketten, die ausschließlich aus Buchstaben (inklusive deutschen Umlauten und ß) bestehen.
| A | B | |
|---|---|---|
| 1 | ^[a-zA-ZäöüÄÖÜß]+$ | |
| 2 | ||
| 3 | Straße | WAHR |
| 4 | Öffentlich | WAHR |
| 5 | Hier kommt Text mit Zahl 1 | FALSCH |
| 6 | Härte | WAHR |
| 7 | 11111 33333 | FALSCH |
Muster: ^[A-Z]+-[A-Z]+\d{2}$
Beschreibung: Findet Codes im Format ABC-XYZ12 (Großbuchstaben mit einem Bindestrich und zwei Ziffern am Ende).
| A | B | |
|---|---|---|
| 1 | ^[A-Z]+-[A-Z]+\d{2}$ | |
| 2 | ||
| 3 | REGEX-TEST23 | WAHR |
| 4 | regex-test23 | FALSCH |
| 5 | ABCDEFG-ABCDE12 | WAHR |
| 6 | A-B12 | WAHR |
| 7 | 1234-1212 | FALSCH |
Muster: ^[^\s]+$
Beschreibung: Findet Zeichenketten ohne Leerzeichen.
| A | B | |
|---|---|---|
| 1 | ^[^\s]+$ | |
| 2 | ||
| 3 | KeinLeerzeichen | WAHR |
| 4 | Text mit Leerzeichen | FALSCH |
| 5 | 123 abc | FALSCH |
| 6 | 123abc | WAHR |
| 7 | abc123 | WAHR |
Muster: ^[^0-9]+$
Beschreibung: Überprüft Zeichenketten, die keine Zahlen enthalten.
| A | B | |
|---|---|---|
| 1 | ^[^0-9]+$ | |
| 2 | ||
| 3 | Hier kommt ein Text | WAHR |
| 4 | 12 | FALSCH |
| 5 | Hier Text mit Zahl 1 | FALSCH |
| 6 | Abc | WAHR |
| 7 | Abc 1 | FALSCH |
Mittelschwere Beispiele für die Excel Funktion REGEXTESTEN
Muster: ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
Beschreibung: Überprüft die Gültigkeit von E-Mail-Adressen.
| A | B | |
|---|---|---|
| 1 | ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ | |
| 2 | ||
| 3 | chris@test.com | WAHR |
| 4 | chris@test | FALSCH |
| 5 | chris@hierkommteintest | FALSCH |
| 6 | chris.test@test.test.com | WAHR |
| 7 | abc123 | FALSCH |
Muster: ^(100|[1-9]?\d)$
Beschreibung: Findet Zahlen von 1 bis 100 (inklusive), aber keine negativen Zahlen.
| A | B | |
|---|---|---|
| 1 | ^(100|[1-9]?\d)$ | |
| 2 | ||
| 3 | 1 | WAHR |
| 4 | 12 | WAHR |
| 5 | 99 | WAHR |
| 6 | 101 | FALSCH |
| 7 | 2 | WAHR |
Muster: ^((D|AT|CH)-)?\d{5}$
Beschreibung: Überprüft deutsche, österreichische oder Schweizer Postleitzahlen, optional mit Länderpräfix.
| A | B | |
|---|---|---|
| 1 | ^((D|AT|CH)-)?\d{5}$ | |
| 2 | ||
| 3 | D-12345 | WAHR |
| 4 | AT-12345 | WAHR |
| 5 | B-12345 | FALSCH |
| 6 | CH-12345 | WAHR |
| 7 | 12345 | WAHR |
Muster: ^(\+49|0)[1-9]\d{1,3}/\d{3,8}$
Beschreibung: Überprüft Telefonnummern im deutschen Format (z. B. +49 123/456789 oder 0123/456789).
| A | B | |
|---|---|---|
| 1 | ^(\+49|0)[1-9 ]\d{1,3}/\d{3,8}$ | |
| 2 | ||
| 3 | +49 123/456789 | WAHR |
| 4 | 123/456789 | FALSCH |
| 5 | 0123/12345 | WAHR |
| 6 | 123456 | FALSCH |
| 7 | Text | FALSCH |
Muster: ^<\w+>$
Beschreibung: Findet einfache HTML-Anfangs-Tags (keine Attribute).
| A | B | |
|---|---|---|
| 1 | ^<\w+>$ | |
| 2 | ||
| 3 | <div> | WAHR |
| 4 | 12345 | FALSCH |
| 5 | abcde | FALSCH |
| 6 | </div> | FALSCH |
| 7 | <strong> | WAHR |
Muster: ^<\/?\w+(\s+\w+=(["'][^"']*["']))*\s*\/?>$
Findet öffnende und schließende HTML-Tags mit und ohne Parameter.
Muster: ^<(\w+)(\s+\w+=(["'][^"']*["']))*\s*>.*<\/\1>$
Findet die passenden öffnenden und schließenden HTML-Tags mit gleichen Namen.
| A | B | |
|---|---|---|
| 1 | ^<\/?\w+(\s+\w+=(["'][^"']*["']))*\s*\/?>$ | |
| 2 | ||
| 3 | <div> | WAHR |
| 4 | <div style="background-color: black"> | WAHR |
| 5 | </div> | WAHR |
| 6 | </img> | WAHR |
| 7 | < td <> | FALSCH |
Muster: ^<!–.*?–>$
Beschreibung: Findet gültige HTML-Kommentare.
| A | B | |
|---|---|---|
| 1 | ^<!–.*?–>$ | |
| 2 | ||
| 3 | <! Kommentar> | FALSCH |
| 4 | <!– Kommentar –> | WAHR |
| 5 | <!- Kommentar –> | FALSCH |
| 6 | <DIV> | FALSCH |
| 7 | <TABLE> | FALSCH |
Muster: ^0x[A-Fa-f0-9]+$
Beschreibung: Findet Hexadezimalzahlen, die mit 0x beginnen.
| A | B | |
|---|---|---|
| 1 | ^0x[A-Fa-f0-9]+$ | |
| 2 | ||
| 3 | 0x1A3F | WAHR |
| 4 | 1A3F | FALSCH |
| 5 | 12345 | FALSCH |
| 6 | Ab1234 | FALSCH |
| 7 | 0xa | WAHR |
Muster: ^(\d{1,3}.){3}\d{1,3}$
Beschreibung: Findet IPv4-Adressen, z. B. 192.168.0.1.
| A | B | |
|---|---|---|
| 1 | ^(\d{1,3}.){3}\d{1,3}$ | |
| 2 | ||
| 3 | 192.168.1.1 | WAHR |
| 4 | 1234.122.2.1 | FALSCH |
| 5 | 1.1.1.1 | WAHR |
| 6 | Text | FALSCH |
| 7 | A.b.C.D | FALSCH |
Muster: ^\d{3}-\d{2}-\d{4}$
Beschreibung: Findet Zeichenketten im Format einer Sozialversicherungsnummer (SSN) aus den USA: genau 3 Ziffern, gefolgt von einem Bindestrich, dann 2 Ziffern, einem weiteren Bindestrich und 4 Ziffern.
| A | B | |
|---|---|---|
| 1 | ^\d{3}-\d{2}-\d{4}$ | |
| 2 | ||
| 3 | 111-22-3333 | WAHR |
| 4 | Text | FALSCH |
| 5 | Text mit 111-22-3333 | FALSCH |
| 6 | 123-45-6789 | WAHR |
| 7 | 11111 33333 | FALSCH |
Muster: ^#[0-9A-Fa-f]{6}$
Beschreibung: Findet Hexadezimal-Farbwerte im Format #RRGGBB (z. B. #FF5733).
| A | B | |
|---|---|---|
| 1 | ^#[0-9A-Fa-f]{6}$ | |
| 2 | ||
| 3 | #FF5733 | WAHR |
| 4 | FF5733 | FALSCH |
| 5 | #000000 | WAHR |
| 6 | #00000G | FALSCH |
| 7 | 123456 | FALSCH |
Muster: ^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$
Beschreibung: Findet gültige Hex-Farbwerte mit 6 (RGB) oder 8 (RGBA) Zeichen.
| A | B | |
|---|---|---|
| 1 | ^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$ | |
| 2 | ||
| 3 | #FF5733 | WAHR |
| 4 | #FF573K | FALSCH |
| 5 | #12345678 | WAHR |
| 6 | #FF5733AA | WAHR |
| 7 | #FF5733KA | FALSCH |
Muster: ^https?://[a-zA-Z0-9.-]+(.[a-zA-Z]{2,})$
Beschreibung: Findet einfache URLs mit http:// oder https:// am Anfang.
| A | B | |
|---|---|---|
| 1 | ^https?://[a-zA-Z0-9.-]+(.[a-zA-Z]{2,})$ | |
| 2 | ||
| 3 | https://example.com | WAHR |
| 4 | http://example.com | WAHR |
| 5 | https://sub.example.com | WAHR |
| 6 | ftp://example.com | FALSCH |
| 7 | Normaler Text | FALSCH |
Muster: ^[A-ZÄÖÜ]{1,3}-[A-Z]{1,2} \d{1,4}$
Beschreibung: Findet gültige deutsche Kfz-Kennzeichen.
| A | B | |
|---|---|---|
| 1 | ^[A-ZÄÖÜ]{1,3}-[A-Z]{1,2} \d{1,4}$ | |
| 2 | ||
| 3 | M-AB 1234 | WAHR |
| 4 | B-TP 1234 | WAHR |
| 5 | ABCD-12345 | FALSCH |
| 6 | MG-A 2345 | WAHR |
| 7 | AB1123 | FALSCH |
Komplexere Beispiele für die Excel Funktion REGEXTESTEN
Muster: ^[^()]*\(([^()]*)\)[^()]*$
Beschreibung: Überprüft Zeichenketten mit genau einem runden Klammerpaar und optionalem Inhalt.
Muster: .*\(.*\).*
Beschreibung: Dieses Muster überprüft nur ob es irgendwo ein Klammerpaar gibt. Die obere Variante ist wesentlich spezifischer.
| A | B | |
|---|---|---|
| 1 | ^[^()]*\(([^()]*)\)[^()]*$ | |
| 2 | ||
| 3 | Datei (mit) einem besseren Inhalt | WAHR |
| 4 | Datei (mit) noch (mehr) | FALSCH |
| 5 | Nur ein (Klammerpaar) erlaubt | WAHR |
| 6 | Dateiname.htp | FALSCH |
| 7 | Dateiname.png | FALSCH |
Muster: ^(https?:\/\/)?(www\.)?[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:\d+)?(\/[a-zA-Z0-9._%+-]*)*$
Beschreibung: Findet URLs mit optionalem http(s):// und www. Ohne Parameterangabe.
| A | B | |
|---|---|---|
| 1 | ^(https?:\/\/)?(www\.)?[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:\d+)?(\/[a-zA-Z0-9._%+-]*)*$ | |
| 2 | ||
| 3 | https://www.example.com/pfad | WAHR |
| 4 | https://www.example.com:4000 | WAHR |
| 5 | https://www.example.com?a=10&b=12 | FALSCH |
| 6 | http://example.com | WAHR |
| 7 | http://sub.example.com/pfad/abc | WAHR |
Muster: (?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$
Beschreibung: Überprüft Passwörter mit mindestens 8 Zeichen, die aus Buchstaben, Zahlen und Sonderzeichen bestehen.
| A | B | |
|---|---|---|
| 1 | (?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$ | |
| 2 | ||
| 3 | Password1! | WAHR |
| 4 | Passwort | FALSCH |
| 5 | einPass!Wort1 | WAHR |
| 6 | %Wort007 | WAHR |
| 7 | EinPasswortWasNichtGeht | FALSCH |
Muster: ^((25[0-5]|2[0-4]\d|1\d{2}|\d{1,2})\.){3}(25[0-5]|2[0-4]\d|1\d{2}|\d{1,2})$
Beschreibung: Überprüft IPv4-Adressen mit gültigen Werten (0–255).
Achtet darauf dass die IP-Adressen nicht als Zahl interpretiert werden. Das seht Ihr in der Eingabezeile (falls die Punkte fehlen).
| A | B | |
|---|---|---|
| 1 | ^((25[0-5]|2[0-4]\d|1\d{2}|\d{1,2})\.){3}(25[0-5]|2[0-4]\d|1\d{2}|\d{1,2})$ | |
| 2 | ||
| 3 | 192.168.0.1 | WAHR |
| 4 | 256.300.1.1 | FALSCH |
| 5 | 186.155.109.A | FALSCH |
| 6 | 255.155.1.1 | WAHR |
| 7 | 1234567890 | FALSCH |
Muster: ^(?i)(.)(.?).?\2\1$
Beschreibung: Findet Palindrome mit maximal 5 Zeichen (z. B. "ebbe oder radar").
| A | B | |
|---|---|---|
| 1 | ^(?i)(.)(.?).?\2\1$ | |
| 2 | ||
| 3 | Ebbe | WAHR |
| 4 | Radar | WAHR |
| 5 | lol | WAHR |
| 6 | wow | WAHR |
| 7 | Abba | WAHR |
Hinweis zu Datumswerten in der Excel Funktion REGEXTESTEN
Hinweis: In Excel werden Datumswerte intern als fünfstellige Zahlen gespeichert. Beispielsweise entspricht das Datum 20.12.2024 der Zahl 45676 (Anzahl der Tage seit dem 1. Januar 1900). Das führt dazu, dass ein regulärer Ausdruck wie ^\d{5}$ WAHR zurück liefert, wenn ein Datum im normalen Datumsformat eingegeben wurde.
Wie kann man mit Datumswerten arbeiten?
Variante 1 Direktes Testen der internen Zahlen:
Ihr könnt das Muster ^\d{5}$ verwenden, um Excel-Datumswerte zu testen. Beachtet jedoch, dass auch beliebige fünfstellige Zahlen (z. B. 12345) als WAHR erkannt werden.
| A | B | C | |
|---|---|---|---|
| 1 | ^\d{5}$ | ||
| 2 | Hinweis: | ||
| 3 | 23.01.2024 | FALSCH | Datum als Text formatiert |
| 4 | 20.12.2025 | WAHR | Datum als Datum formatiert |
| 5 | 232323 | FALSCH | |
| 6 | 23233 | WAHR |
Variante 2: Konvertierung ins Textformat
Ihr könnt Zellen über die rechte Maustaste formatieren und wählt dann Text aus.
| A | B | C | |
|---|---|---|---|
| 1 | ^\d{2}\.\d{2}\.\d{4}$ | ||
| 2 | Hinweis: | ||
| 3 | 23.01.2024 | WAHR | Datum als Text formatiert |
| 4 | 20.12.2025 | FALSCH | Datum als Datum formatiert |
| 5 | 232323 | FALSCH | |
| 6 | 23233 | FALSCH | |
| 7 | FALSCH |
Muster: ^\d{4}-\d{2}-\d{2}$
Beschreibung: Findet Datumsangaben im ISO-Format JJJJ-MM-TT (z. B. 2024-11-23).
| A | B | C | |
|---|---|---|---|
| 1 | ^\d{4}-\d{2}-\d{2}$ | ||
| 2 | Hinweis: | ||
| 3 | 2025-12-23 | WAHR | Als Text formatiert |
| 4 | 23.12.2025 | FALSCH | Als Datum formatiert |
| 5 | 12.12.2024 | FALSCH | |
| 6 | Abcd-ab-ab | FALSCH | |
| 7 | 12345678 | FALSCH |
Hinweis zu Uhrzeiten in der Excel Funktion REGEXTESTEN
Muster: ^\d{2}:\d{2}(:\d{2})?$
Beschreibung: Findet Zeitangaben im Format HH:MM oder HH:MM:SS.
Hinweis: Ähnlich wie mit dem Datum müsst Ihr die Uhrzeiten erst als Text formatieren damit der reguläre Ausdruck korrekt funktioniert.
| A | B | C | |
|---|---|---|---|
| 1 | ^\d{2}:\d{2}(:\d{2})?$ | ||
| 2 | Hinweis: | ||
| 3 | 14:33:22 | WAHR | Als Text formatiert |
| 4 | 14:33:22 | FALSCH | Als Uhrzeit formatiert |
| 5 | 22:10 | WAHR | Als Text formatiert |
| 6 | 22:10 | FALSCH | Als Uhrzeit formatiert |
| 7 | aa:bb:cc | FALSCH |
Hinweis zu Zahlen mit 1000er Trennpunkte in der Excel Funktion REGEXTESTEN
Hinweis: Zahlen müssen als Text vorliegen, damit dieses Muster funktioniert. Tausendertrennzeichen und Dezimalstellen werden nur in Textform korrekt geprüft.
Muster: ^([1-9]\d{0,2}(\.\d{3})*|0)(,\d+)?$
Beschreibung: Findet Zahlen im Format mit Tausendertrennzeichen (z. B. 1.000,50).
| A | B | C | |
|---|---|---|---|
| 1 | ^([1-9]\d{0,2}(\.\d{3})*|0)(,\d+)?$ | ||
| 2 | Hinweis: | ||
| 3 | 1,000 | WAHR | Als Zahl formatiert |
| 4 | 10,000 | WAHR | Als Zahl formatiert |
| 5 | 100.000.000 | WAHR | Als Text formatiert |
| 6 | 1.000,222 | FALSCH | Als Zahl formatiert |
| 7 | 10.000,1 | WAHR | Als Text formatiert |
So, dass soll es jetzt erst einmal gewesen sein. Ich denke mit der Zeit wird noch einiges hinzukommen.
Ihr möchtet Euch gerne für meine Mühe bedanken?
Hier habt Ihr die Möglichkeit AMAZON – Wunschliste [HIER KLICKEN]
Vielen Dank für Eure Unterstützung 🙂
Nachfolgend könnt Ihr Euch gerne das Video anschauen um erste Grundlagen kennenzulernen. Außerdem seht Ihr wie ich die Tabelle aufgebaut habe.
Hier das Video: "REGEXTESTEN Reguläre Ausdrücke mit vielen Beispielen mit Excel 365"