REGEXMATCH 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 Google Tabellen 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 REGEXEXTRACT oder REGEXREPLACE 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 REGEXMATCH 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 REGEXMATCH-DOWNLOADVERSION.xlsx
Download REGEXMATCH-DOWNLOADVERSION.xlsx als ZIP Datei
Die Datei könnt Ihr ganz einfach in Google Tabellen importieren: Datei – > Importieren – > Hochladen – > Speicherort "Neue Tabelle erstellen" – > Daten importieren Fertig 😊
Google kann ohne Probleme die xlsx Datei verarbeiten
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 REGEXMATCH
Die Funktion REGEXMATCH 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.
REGEXMATCH(Text; Muster)
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 RE2-Syntax verwendet.
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" |
[A-Za-z0-9_] |
Alphanumerisches Zeichen oder Unterstrich | [A-Za-z0-9_]+ findet "abc_123" |
[^A-Za-z0-9_] |
Kein alphanumerisches Zeichen | [^A-Za-z0-9_]+ 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" |
Maskierung von Metazeichen in der Google Tabellen-Funktion REGEXMATCH
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 (als \\ in Formeln) |
. |
Beliebiges Zeichen (außer Zeilenumbruch) | Ja, wenn ihr einen Punkt suchen möchtet (als \.) |
^ |
Anfang eines Strings oder einer Zeile | Ja, wenn ihr ^ suchen möchtet (als \^) |
$ |
Ende eines Strings oder einer Zeile | Ja, wenn ihr $ suchen möchtet (als \$) |
* |
Wiederholung (0 oder mehr) | Ja, wenn ihr * suchen möchtet (als \*) |
+ |
Wiederholung (1 oder mehr) | Ja, wenn ihr + suchen möchtet (als \+) |
? |
Optional (0 oder 1) | Ja, wenn ihr ? suchen möchtet (als \?) |
{ } |
Quantifizierer (z. B. {1,3}) |
Ja, wenn ihr { oder } suchen möchtet (als \{ oder \}) |
( ) |
Gruppierung oder Capturing Groups | Ja, wenn ihr ( oder ) suchen möchtet (als \( oder \)) |
[ ] |
Zeichenklassen | Ja, wenn ihr [ oder ] suchen möchtet (als \[ oder \]) |
| |
ODER-Bedingung | Ja, wenn ihr | suchen möchtet (als \|) |
/ |
Schrägstrich (kein spezielles Zeichen in RE2) | Nein |
- |
Spanne in Zeichenklassen (z. B. [a-z]) |
Ja, wenn ihr den Bindestrich innerhalb von Zeichenklassen verwenden möchtet (z. B. zwischen anderen Zeichen, als \-).Am Anfang oder Ende der Zeichenklasse muss er nicht maskiert werden. |
` |
Backtick (keine spezielle Bedeutung) | Nein |
Einfache Beispiele für die Google Tabellen Funktion REGEXMATCH
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 ein langer Text | false |
| 4 | Hier kommt Text | false |
| 5 | Hier kommt | true |
| 6 | Hier 123 | true |
| 7 | Wenig | false |
Muster: ^\d{4}$
Beschreibung: Findet genau 4-stellige Zahlen (z. B. PIN-Codes oder kurze IDs).
| # | A | B |
|---|---|---|
| 1 | ^\d{4}$ | |
| 2 | ||
| 3 | 1 | false |
| 4 | 1234 | true |
| 5 | 12345 | false |
| 6 | abcd | false |
| 7 | 1111 | true |
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 | true |
| 4 | 1234 | false |
| 5 | 123456 | false |
| 6 | abcde | false |
| 7 | a1234 | false |
Muster: ^-?\d+(,\d+)?$
Beschreibung: Findet positive oder negative Dezimalzahlen.
| # | A | B |
|---|---|---|
| 1 | ^-?\d+(,\d+)?$ | |
| 2 | ||
| 3 | 12345 | true |
| 4 | -12345.66 | true |
| 5 | Text | false |
| 6 | 12345,55 Text | false |
| 7 | Abcd Text | false |
Muster: ^-?\d+,\d+$
Beschreibung: Überprüft Dezimalzahlen mit mindestens einer Ziffer vor und nach dem Komma.
| # | A | B |
|---|---|---|
| 1 | ^-?\d+,\d+$ | |
| 2 | ||
| 3 | 343432344 | false |
| 4 | 3.3 | true |
| 5 | 2323.4444 | true |
| 6 | -343434 | false |
| 7 | Abcd,Text | false |
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 | true |
| 4 | Test@123 | false |
| 5 | Zusammenhängend | false |
| 6 | Zusammenhaengend | true |
| 7 | Kurzer Text mit Leerzeichen | false |
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.jpg | true |
| 4 | Dateiname.txt | false |
| 5 | Dateiname.gif | true |
| 6 | Dateiname | false |
| 7 | .gif | false |
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 | false |
| 4 | Rabe | true |
| 5 | Katze | false |
| 6 | Amsel | false |
| 7 | Raupe | true |
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 | abcdef | false |
| 4 | a | true |
| 5 | 12345 | false |
| 6 | 1 | false |
| 7 | z | true |
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 | klein | true |
| 4 | Gross | false |
| 5 | hier mit leerzeichen | false |
| 6 | hierohneleerzeichen | true |
| 7 | 12345 | false |
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 | G | true |
| 4 | a | false |
| 5 | ZUVIEL | false |
| 6 | B | true |
| 7 | 12345 | false |
Muster: ^[a-zA-Z]$
Beschreibung: Findet genau einen Buchstaben, unabhängig von Groß- oder Kleinschreibung.
| # | A | B |
|---|---|---|
| 1 | ^[a-zA-Z]$ | |
| 2 | ||
| 3 | a | true |
| 4 | B | true |
| 5 | aB | false |
| 6 | C | true |
| 7 | 12345 | false |
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 | Normaler Text | false |
| 4 | TEXT-MIT-BINDESTRICH | true |
| 5 | Text-mit-Bindestrich | false |
| 6 | HIER-NOCHMAL-RICHTIG | true |
| 7 | 12345-12345 | false |
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 | true |
| 4 | max mustermann | false |
| 5 | Max mustermann | false |
| 6 | Max | true |
| 7 | Frau Mustermann | true |
Muster: ^\w+$
Beschreibung: Findet Zeichenketten, die nur aus Buchstaben, Ziffern oder Unterstrichen bestehen.
| # | A | B |
|---|---|---|
| 1 | ^\w+$ | |
| 2 | ||
| 3 | Eintrag | true |
| 4 | 12345 | true |
| 5 | Hier_kommt_ein_Text | true |
| 6 | Hier kommt Text! | false |
| 7 | Hier-kommt-ein-Text | false |
Muster: ^\w{8,}$
Beschreibung: Findet Zeichenketten mit mindestens 8 Zeichen, die Buchstaben, Ziffern oder Unterstriche enthalten.
Keine ÄÖÜäöüß in \w enthalten.
| # | A | B |
|---|---|---|
| 1 | ^\w{8,}$ | |
| 2 | ||
| 3 | ZuKurz | false |
| 4 | Hier_etwas_laenger | true |
| 5 | Hieretwaslängermitä | false |
| 6 | Hieretwaslaengermitae | true |
| 7 | Hier-kommt-ein-Text | false |
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 | true |
| 4 | 12345X | false |
| 5 | 1234567890 | true |
| 6 | ABCDEFGHX | false |
| 7 | 987654321X | true |
Muster: \d+
Beschreibung: Findet eine oder mehrere Ziffern.
| # | A | B |
|---|---|---|
| 1 | \d+ | |
| 2 | ||
| 3 | abcde | false |
| 4 | ab ab | false |
| 5 | 1234 | true |
| 6 | abcde abcd abcd 3333 | true |
| 7 | 987654321X | true |
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 | true |
| 4 | Text mit Leerzeichen | false |
| 5 | TextohneLeerzeichen | true |
| 6 | TextmitZahlen1234 | false |
| 7 | Zusammenhang | true |
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 | true |
| 4 | falsch | false |
| 5 | Auch falsch | false |
| 6 | Das vielleicht? | false |
| 7 | Perfekt | true |
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 | true |
| 4 | Öffentlich | true |
| 5 | Mit Leerzeichen | false |
| 6 | Mit-Bindestrich | false |
| 7 | Außergewöhnlich | true |
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-Test12 | false |
| 4 | REGEX-TEST12 | true |
| 5 | Gross-klein1234 | false |
| 6 | Text-Test12 | false |
| 7 | TEXT-TEST99 | true |
Muster: ^[^\s]+$
Beschreibung: Findet Zeichenketten ohne Leerzeichen.
| # | A | B |
|---|---|---|
| 1 | ^[^\s]+$ | |
| 2 | ||
| 3 | Ein kleiner Text | false |
| 4 | Ein-kleiner-Text | true |
| 5 | Ein_kleiner_Text | true |
| 6 | EinkleinerText | true |
| 7 | Text mit einigen Leerzeichen | false |
Muster: ^[^0-9]+$
Beschreibung: Überprüft Zeichenketten, die keine Zahlen enthalten.
| # | A | B |
|---|---|---|
| 1 | ^[^0-9]+$ | |
| 2 | ||
| 3 | Ein Text ohne Zahlen | true |
| 4 | Ein Text mit einer Zahl 1 | false |
| 5 | 12345 | false |
| 6 | Text | true |
| 7 | Alles erlaubt außer Zahlen | true |
Mittelschwere Beispiele für die Google Tabellen Funktion REGEXMATCH
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 | true |
| 4 | Chris@ | false |
| 5 | Test.com | false |
| 6 | Leider keine Emailadresse | false |
| 7 | Hier-kommt-meine@adresse.com | true |
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 | true |
| 4 | 200 | false |
| 5 | 99 | true |
| 6 | 101 | false |
| 7 | 2 | true |
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 | true |
| 4 | P-45678 | false |
| 5 | 12345 | true |
| 6 | AT12345 | false |
| 7 | AT-12345 | true |
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).
Hinweis: Die Eingabe erfolgte in Textformat: '+49 123/456789 (Hochkomma vorangestellt)
| # | A | B |
|---|---|---|
| 1 | ^(\+49|0)[1-9 ]\d{1,3}/\d{3,8}$ | |
| 2 | ||
| 3 | +49 123/456789 | true |
| 4 | 123/456789 | false |
| 5 | 12345 | false |
| 6 | 0123/12345 | true |
| 7 | Hier kommt ein kleiner Text | false |
Muster: ^<\w+>$
Beschreibung: Findet einfache HTML-Anfangs-Tags (keine Attribute).
| # | A | B |
|---|---|---|
| 1 | ^<\w+>$ | |
| 2 | ||
| 3 |
<div>
|
true |
| 4 | 12345 | false |
| 5 | ABC | false |
| 6 | <strong> | true |
| 7 | <Hier kommt etwas Text | false |
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>
|
true |
| 4 | <div style="background-color: black"> | true |
| 5 | ABC | false |
| 6 | </strong> | true |
| 7 | < td <> | false |
Muster: ^<!–.*?–>$
Beschreibung: Findet gültige HTML-Kommentare.
| # | A | B |
|---|---|---|
| 1 | ^$ | |
| 2 | ||
| 3 | <! Kommentar> | false |
| 4 | <!– Kommentar –> | true |
| 5 | <!- Kommentar –> | false |
| 6 |
<DIV>
|
false |
| 7 | <TABLE> | false |
Muster: ^0x[A-Fa-f0-9]+$
Beschreibung: Findet Hexadezimalzahlen, die mit 0x beginnen.
| # | A | B |
|---|---|---|
| 1 | ^0x[A-Fa-f0-9]+$ | |
| 2 | ||
| 3 | 0x1A3F | true |
| 4 | 1A3F | false |
| 5 | 12345 | false |
| 6 | Ab1234 | false |
| 7 | 0xa | true |
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 | true |
| 4 | 1234.122.2.1 | false |
| 5 | 1.1.1.1 | true |
| 6 | Text | false |
| 7 | A.b.C.D | false |
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 | true |
| 4 | 1234.122.2.1 | false |
| 5 | Text mit 111-22-3333 | false |
| 6 | 123-45-6789 | true |
| 7 | 11-22-12345 | false |
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 | true |
| 4 | FF5733 | false |
| 5 | #000000 | true |
| 6 | #00000G | false |
| 7 | 123456 | false |
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 | true |
| 4 | FF5733 | false |
| 5 | #FF573K | false |
| 6 | #12345678 | true |
| 7 | #FF5733KA | false |
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 | true |
| 4 | http://example.com | true |
| 5 | https://sub.example.com | true |
| 6 | ftp://example.com | false |
| 7 | Normaler Text | false |
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 | true |
| 4 | B-TP 1234 | true |
| 5 | ABCD-12345 | false |
| 6 | MG-A 2345 | true |
| 7 | AB1123 | false |
Komplexere Beispiele für die Google Tabellen Funktion REGEXMATCH
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 | true |
| 4 | Datei (mit) noch (mehr) | false |
| 5 | Nur ein (Klammerpaar) erlaubt | true |
| 6 | Ein kleiner Text | false |
| 7 | Betrag (1.500€) inkl. MwSt. | true |
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 | true |
| 4 | https://www.example.com:4000 | true |
| 5 | https://www.example.com?a=10&b=12 | false |
| 6 | http://example.com | true |
| 7 | http://sub.example.com/pfad/abc | true |
Passwörter mit mindestens 8 Zeichen, die aus Buchstaben, Zahlen und Sonderzeichen bestehen.
Leider habe ich keine andere Möglichkeit gefunden das in einem einzigen Muster festzulegen da Google Tabellen momentan noch keine Lookahead und Lookbehinds unterstützt.
Deshalb muss das auf mehrere Funktionen aufgeteilt werden. Die Funktion sieht dann folgendermaßen aus:
Mit dieser Formel wird sichergestellt, dass:
- Das Passwort mindestens 8 Zeichen lang ist.
- Mindestens einen Buchstaben enthält.
- Mindestens eine Ziffer enthält.
- Mindestens ein erlaubtes Sonderzeichen enthält.
- Nur aus erlaubten Zeichen besteht.
=UND(
LÄNGE(A1)>=8;
REGEXMATCH(A1; "[A-Za-z]");
REGEXMATCH(A1; "\d");
REGEXMATCH(A1; "[@$!%*?&]");
REGEXMATCH(A1; "^[A-Za-z\d@$!%*?&]+$")
)
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).
| # | 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 | true |
| 4 | 256.300.1.1 | false |
| 5 | 186.155.109.A | false |
| 6 | 255.155.1.1 | true |
| 7 | 1234567890 | false |
Datumswerte in der Google Tabellen Funktion REGEXMATCH
Muster: ^\d{2}\.\d{2}\.\d{4}$
Beschreibung: Findet ein Datum im Format 23.07.2025
| # | A | B |
|---|---|---|
| 1 | ^\d{2}\.\d{2}\.\d{4}$ | |
| 2 | ||
| 3 | 00:00:00 | true |
| 4 | 12345 | false |
| 5 | 186.155.109.A | false |
| 6 | 255.155.1.1 | false |
| 7 | 1234567890 | false |
Muster: ^\d{4}-\d{2}-\d{2}$
Beschreibung: Findet Datumsangaben im ISO-Format JJJJ-MM-TT (z. B. 2024-11-23).
Beim Eintragen von 2025-12-23 wird das Datum in 23.12.2025 umgewandelt. Entsprechend muss das Format dann als Text vorliegen. Ihr könnt natürlich auch ein ' (Hochkomma) davor setzen.
| # | A | B |
|---|---|---|
| 1 | ^\d{4}-\d{2}-\d{2}$ | |
| 2 | ||
| 3 | 2025-12-23 | true |
| 4 | 12345 | false |
| 5 | 00:00:00 | false |
| 6 | Abcd-ab-ab | false |
| 7 | 1234567890 | false |
Uhrzeiten in der Google Tabellen Funktion REGEXMATCH
Muster: ^\d{2}:\d{2}(:\d{2})?$
Beschreibung: Findet Zeitangaben im Format HH:MM oder HH:MM:SS.
| # | A | B |
|---|---|---|
| 1 | ^\d{2}:\d{2}(:\d{2})?$ | |
| 2 | ||
| 3 | 12:40:39 | true |
| 4 | 14:35:34 | true |
| 5 | 12:1 | false |
| 6 | 02:23:39 | true |
| 7 | 1234567890 | false |
Zahlen mit 1000er Trennpunkte in der Google Tabellen Funktion REGEXMATCH
Hinweis: Ihr müsst darauf achten ob das Format welches Ihr seht mit Eurem Muster übereinstimmt.
Am Besten werden Einträge im Textformat verarbeitet. Es könnte je nach Anwendungsfall erforderlich sein eine Zahl in Text zu konvertieren. Ihr könnt dass ganz einfach machen indem Ihr ein Hochkomma vor die Zahl schreibt. Also einfach ein ' vor die Zahl und dann wird es direkt als Text erkannt und kann entsprechend über den regulären Ausdruck, also Eurem Muster, besser verarbeitet werden.
Muster: ^([1-9]\d{0,2}(\.\d{3})*|0)(,\d+)?$
Beschreibung: Findet Zahlen im Format mit Tausendertrennzeichen (z. B. 1.000,50).
| # | A | B |
|---|---|---|
| 1 | ^([1-9]\d{0,2}(\.\d{3})*|0)(,\d+)?$ | |
| 2 | ||
| 3 | 1000 | false |
| 4 | 10000000 | false |
| 5 | 100000000 | true |
| 6 | 0 | true |
| 7 | -1000000 | false |
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 🙂