REGEXEXTRACT 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 REGEXMATCH 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 REGEXEXTRACT und zusätzlich die bedingte Formatierung, um Zellen zu markieren die leer sind.
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 erfolgen dann die Ausgaben die durch das Muster festgelegt wurden.
HIER DER DOWNLOAD der Vorlage:
Download REGEXEXTRACT-DOWNLOADVERSION.xlsx
Download REGEXEXTRACT-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 ab und überlegt, welche Antwort Ihr erwarten würdest. So könnt Ihr Euer Wissen testen! 🙂
Funktionsaufbau von REGEXEXTRACT
Die Funktion REGEXEXTRACT extrahiert den Teil des Textes, der mit dem angegebenen regulären Ausdruck (Muster) übereinstimmt.
REGEXEXTRACT(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 REGEXEXTRACT
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 REGEXEXTRACT
Muster: \d+
Beschreibung: Extrahiert eine oder mehrere aufeinanderfolgende Ziffern.
| # | A | B |
|---|---|---|
| 1 | \d+ | |
| 2 | ||
| 3 | abc123def | 123 |
| 4 | 456xyz | 456 |
| 5 | Keine Zahlen | |
| 6 | 1000 mal | 1000 |
| 7 | 78-90 | 78 |
Muster: \d*
Beschreibung: Findet null oder mehr aufeinanderfolgende Ziffern.
| # | A | B |
|---|---|---|
| 1 | \d* | |
| 2 | ||
| 3 | Hallo erstmal | |
| 4 | 123 456 | 123 |
| 5 | 123 Test | 123 |
| 6 | Test 123 | |
| 7 | 1000 | 1000 |
Muster: \d?
Beschreibung: Findet null oder genau eine Ziffer.
| # | A | B |
|---|---|---|
| 1 | \d? | |
| 2 | ||
| 3 | Hallo erstmal | |
| 4 | 123 456 | 1 |
| 5 | 123 Test | 1 |
| 6 | Test 123 | |
| 7 | 1000 | 1 |
Muster: a.*b
Beschreibung: Findet Zeichenfolgen, die mit einem a beginnen, beliebige Zeichen enthalten und mit einem b enden.
| # | A | B |
|---|---|---|
| 1 | a.*b | |
| 2 | ||
| 3 | abc | ab |
| 4 | am besten | am b |
| 5 | Hier kommt mal ein b | al ein b |
| 6 | Hier kommt keins vor | |
| 7 | al12345b | al12345b |
Muster: ^[A-Za-z]+$
Beschreibung: Extrahiert nur Wörter, die ausschließlich aus Buchstaben bestehen (keine Zahlen oder Sonderzeichen).
| # | A | B |
|---|---|---|
| 1 | ^[A-Za-z]+$ | |
| 2 | ||
| 3 | Hallo | Hallo |
| 4 | Welt123 | |
| 5 | abcDEF | abcDEF |
| 6 | !Spezial | |
| 7 | Fantastisch | Fantastisch |
Muster: \w+
Beschreibung: Extrahiert einzelne Wörter (alphanumerisch, inklusive Unterstrich).
| # | A | B |
|---|---|---|
| 1 | \w+ | |
| 2 | ||
| 3 | Hallo | Hallo |
| 4 | Hier_kommt_Text | Hier_kommt_Text |
| 5 | Regex.Test | Regex |
| 6 | Hier kommt Text | Hier |
| 7 | Keine_Symbole | Keine_Symbole |
Muster: \b\w{3}\b
Beschreibung: Findet alle Wörter, die genau drei Zeichen lang sind.
| # | A | B |
|---|---|---|
| 1 | \b\w{3}\b | |
| 2 | ||
| 3 | Hut | Hut |
| 4 | Test | |
| 5 | Hier kommt Text | |
| 6 | Hat geklappt | Hat |
| 7 | 123 | 123 |
Muster: \d{2,}
Beschreibung: Extrahiert Zahlen mit mindestens zwei Ziffern.
| # | A | B |
|---|---|---|
| 1 | \d{2,} | |
| 2 | ||
| 3 | abc123 | 123 |
| 4 | 42Hallo | 42 |
| 5 | 9 | |
| 6 | 1000 mal | 1000 |
| 7 | 56 | 56 |
Muster: \b\d{5}\b
Beschreibung: Findet alleinstehende deutsche Postleitzahlen (immer genau 5 Ziffern).
| # | A | B |
|---|---|---|
| 1 | \b\d{5}\b | |
| 2 | ||
| 3 | 12345 | 12345 |
| 4 | Test12345 | |
| 5 | Noch ein Test 12345 | 12345 |
| 6 | 12345 und schon wieder | 12345 |
| 7 | 123456 |
Muster: ^[^aeiouAEIOU]*$
Beschreibung: Extrahiert Zeilen ohne Vokale.
| # | A | B |
|---|---|---|
| 1 | ^[^aeiouAEIOU]*$ | |
| 2 | ||
| 3 | abcdef | |
| 4 | abcdef und ghijklm | |
| 5 | 12345 | 12.345 |
| 6 | 56 | 56 |
| 7 | klmnp | klmnp |
Muster: ^.{4}$
Beschreibung: Findet Zeilen, die genau vier Zeichen lang sind.
| # | A | B |
|---|---|---|
| 1 | ^.{4}$ | |
| 2 | ||
| 3 | Rest | Rest |
| 4 | Komplex | |
| 5 | 1234 | 1234 |
| 6 | 123 | |
| 7 | klmnp |
Muster: \d
Beschreibung: Findet jede einzelne Ziffer.
| # | A | B |
|---|---|---|
| 1 | \d | |
| 2 | ||
| 3 | abc123 | 1 |
| 4 | 456def | 4 |
| 5 | 78-99 | 7 |
| 6 | Keine Zahlen | |
| 7 | 1000 | 1 |
Muster: [aeiou]
Beschreibung: Findet jede der angegebenen Vokale (a, e, i, o, u) einzeln.
| # | A | B |
|---|---|---|
| 1 | [aeiou] | |
| 2 | ||
| 3 | Hallo | a |
| 4 | Welt | e |
| 5 | Regex | e |
| 6 | Himmel | i |
| 7 | AEIOU |
Muster: [^aeiou]
Beschreibung: Findet alle Zeichen außer kleine Vokale.
| # | A | B |
|---|---|---|
| 1 | [^aeiou] | |
| 2 | ||
| 3 | Hallo | H |
| 4 | Welt | W |
| 5 | Regex | R |
| 6 | Himmel | H |
| 7 | AEIOU | A |
Muster: ^\w
Beschreibung: Findet das erste Zeichen eines Wortes, wenn es ein Buchstabe oder eine Zahl ist.
| # | A | B |
|---|---|---|
| 1 | ^\w | |
| 2 | ||
| 3 | Hallo | H |
| 4 | Welt | W |
| 5 | !Wichtig | |
| 6 | Himmel | H |
| 7 | #12345 |
Muster: \s
Beschreibung: Findet Leerzeichen, Tabs oder andere Whitespace-Zeichen.
| # | A | B |
|---|---|---|
| 1 | \s | |
| 2 | ||
| 3 | Hallo erstmal | |
| 4 | 123 456 | |
| 5 | 123456 | |
| 6 | Keine_Ausgabe | |
| 7 | a b |
Muster: \w+$
Beschreibung: Findet das letzte Wort in einer Zeile.
| # | A | B |
|---|---|---|
| 1 | \w+$ | |
| 2 | ||
| 3 | Hallo erstmal | erstmal |
| 4 | 123 456 | 456 |
| 5 | 123456 | 123456 |
| 6 | Keine_Ausgabe | Keine_Ausgabe |
| 7 | a b | b |
Muster: [A-Za-z]+\d+
Beschreibung: Findet Buchstabenfolgen gefolgt von einer oder mehreren Ziffern.
| # | A | B |
|---|---|---|
| 1 | [A-Za-z]+\d+ | |
| 2 | ||
| 3 | ABC mit Zahlen 123 | |
| 4 | 123 456 | |
| 5 | ABC123456 | ABC123456 |
| 6 | 12345 | |
| 7 | a1 | a1 |
Muster: (abc|123)
Beschreibung: Findet entweder die Zeichenfolge abc oder 123.
| # | A | B |
|---|---|---|
| 1 | (abc|123) | |
| 2 | ||
| 3 | ABC mit Zahlen 123 | 123 |
| 4 | 123 456 | 123 |
| 5 | ABC23456 | |
| 6 | 12345 | 123 |
| 7 | efg 234 |
Muster: \b\d{2,4}\b
Beschreibung: Findet Zahlen mit 2 bis 4 Ziffern, die ein eigenes Wort bilden.
| # | A | B |
|---|---|---|
| 1 | \b\d{2,4}\b | |
| 2 | ||
| 3 | Zahlen 1 2 3 45 | 45 |
| 4 | abc 123 | 123 |
| 5 | ABC123 | |
| 6 | 12345 | |
| 7 | efg 345 | 345 |
Mittelschwere Beispiele für die Google Tabellen Funktion REGEXEXTRACT
Muster: \b[A-ZÄÖÜ][a-zäöüß]+\s[A-ZÄÖÜ][a-zäöüß]+\b
Beschreibung: Findet deutsche Namen, bestehend aus Vor- und Nachnamen mit großem Anfangsbuchstaben.
| # | A | B |
|---|---|---|
| 1 | \b[A-ZÄÖÜ][a-zäöüß]+\s[A-ZÄÖÜ][a-zäöüß]+\b | |
| 2 | ||
| 3 | Max Mustermann | Max Mustermann |
| 4 | herr Müller | |
| 5 | Frau meier | |
| 6 | Johann Peter | Johann Peter |
| 7 | 123 Müller |
Muster: ^(DE\d{2} \d{4} \d{4} \d{4} \d{4} \d{4})$
Beschreibung: Findet deutsche IBAN-Nummern im Format DEkk BBBB BBBB BBBB BBBB BB.
| # | A | B |
|---|---|---|
| 1 | ^(DE\d{2} \d{4} \d{4} \d{4} \d{4} \d{2})$ | |
| 2 | ||
| 3 | DE44 5001 0517 5407 3249 31 | DE44 5001 0517 5407 3249 31 |
| 4 | DE89 3704 0044 0532 0130 00 | DE89 3704 0044 0532 0130 00 |
| 5 | DE12 3456 7890 1234 5678 90 | DE12 3456 7890 1234 5678 90 |
| 6 | DE12345678901234567890 | |
| 7 | GB29 NWBK 6016 1331 9268 19 |
Muster: \b\d{3}/\d{3}\b
Beschreibung: Findet Nummern im Format 123/456.
| # | A | B |
|---|---|---|
| 1 | \b\d{3}/\d{3}\b | |
| 2 | ||
| 3 | 123/456 | 123/456 |
| 4 | 1234/4567 | |
| 5 | Nummer 135/895 | 135/895 |
| 6 | 123 456/527 22936 | 456/527 |
| 7 | Abc 123 DEF/123 |
Muster: \b(?:19|20)\d{2}\b
Beschreibung: Findet Jahreszahlen zwischen 1900 und 2099.
| # | A | B |
|---|---|---|
| 1 | \b(?:19|20)\d{2}\b | |
| 2 | ||
| 3 | 1999 | 1999 |
| 4 | 2000 | 2000 |
| 5 | 2001 | 2001 |
| 6 | 3000 | |
| 7 | 1877 |
Muster: \b(?:SK|BG|CY|DE|FR)\d{9,12}\b
Beschreibung: Findet europäische USt-IdNr. für einige Länder (z. B. DE123456789).
| # | A | B |
|---|---|---|
| 1 | \b(?:SK|BG|CY|DE|FR)\d{9,12}\b | |
| 2 | ||
| 3 | DE123456789 | DE123456789 |
| 4 | FR987654321 | FR987654321 |
| 5 | CY123456789123 | CY123456789123 |
| 6 | US123456789 | |
| 7 | DE12345 |
Komplexere Beispiele für die Google Tabellen Funktion REGEXEXTRACT
Muster: ^\w+@\w+\.\w+$
Beschreibung: Findet einfache E-Mail-Adressen wenn diese direkt am Anfang stehen.
| # | A | B |
|---|---|---|
| 1 | ^\w+@\w+\.\w+$ | |
| 2 | ||
| 3 | user@test.com | user@test.com |
| 4 | name@domain.org | name@domain.org |
| 5 | Hier kommt normaler Text | |
| 6 | Hier@ kommt. | |
| 7 | Noch ein Test mit user@test.com |
Muster: ^(\w+)@\w+\.\w+$
Durch die Klammern und damit bilden einer Gruppe, wird der Namensteil vor dem @ ausgegeben, also der Inhalt vom ersten Klammern Paar.
| # | A | B |
|---|---|---|
| 1 | ^(\w+)@\w+\.\w+$ | |
| 2 | ||
| 3 | user@test.com | user |
| 4 | name@domain.org | name |
| 5 | Hier kommt normaler Text | |
| 6 | Hier@ kommt. | |
| 7 | Noch ein Test mit user@test.com |
Muster: ^(?:[A-Za-z]+\s){2,4}\w+$
Beschreibung: Findet Zeilen mit 3 bis 5 Wörtern, wobei Wörter durch Leerzeichen getrennt sind.
| # | A | B |
|---|---|---|
| 1 | ^(?:[A-Za-z]+\s){2,4}\w+$ | |
| 2 | ||
| 3 | Das ist ein kleiner Text | Das ist ein kleiner Text |
| 4 | Wort | |
| 5 | Zwei Worte | |
| 6 | Hier drei Worte | Hier drei Worte |
| 7 | Hier nochmal so ein kleiner Text |
Muster: \b((?:https?://)?(?:www\.)?\w+\.\w+)\b
Beschreibung: Findet URLs und extrahiert die Domain.
Hier ist gut zu sehen wie das mit den Capturing Groups (…) und Non-Capturing (?:….) Groups genau funktioniert.
Hier fängt die äußere Gruppe (äußeres Klammern Paar) alles ein.
| # | A | B |
|---|---|---|
| 1 | \b((?:https?://)?(?:www\.)?\w+\.\w+)\b | |
| 2 | ||
| 3 | https://google.com | https://google.com |
| 4 | http://example.org | http://example.org |
| 5 | Hier kommt www.github.com | www.github.com |
| 6 | kein-protokoll.com | protokoll.com |
| 7 | falsche-url |
Muster: \b((?:https?://)?(?:www\.)?\w+\.\w+)\b
Wenn ich die äußere Klammer entferne und aus den anderen Klammern die ?: entferne, dann sind das wieder Capture Groups.
Die Ausgabe der einzelnen Gruppen geschieht dann in eigenen Zellen.
| # | A | B | C | D |
|---|---|---|---|---|
| 1 | \b(https?://)?(www\.)?(\w+\.\w+)\b | |||
| 2 | ||||
| 3 | https://google.com | https:// | google.com | |
| 4 | http://example.org | http:// | example.org | |
| 5 | Hier kommt www.github.com | www. | github.com | |
| 6 | kein-protokoll.com | protokoll.com | ||
| 7 | falsche-url |
Muster: ([a-zA-Z0-9._%+-]+)@([a-zA-Z0-9.-]+)\.([a-zA-Z]{2,})$
Dieses Muster deckt eine große Vielfalt an E-Mail-Formaten ab, einschließlich Subdomains und mehrteiligen Namen vor dem @.
Durch die Capture Groups werden die Teile der Emailadresse in separaten Zellen eingetragen.
Wollt Ihr eine Gruppe nicht, dann entfernt das Klammer Paar oder setzt ?: direkt hinter die geöffnete Klammer ein.
| # | A | B | C | D |
|---|---|---|---|---|
| 1 | ([a-zA-Z0-9._%+-]+)@([a-zA-Z0-9.-]+)\.([a-zA-Z]{2,})$ | |||
| 2 | ||||
| 3 | valid.email@subdomain.domain.de | valid.email | subdomain.domain | de |
| 4 | support@sub.mailserver.com | support | sub.mailserver | com |
| 5 | @hierfehltdochwas.com | |||
| 6 | name@com | |||
| 7 | user.name@company.com | user.name | company | com |
Muster: (\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[1-2][0-9]|3[01])T(?:[0-1][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9])
Beschreibung: Findet Datums- und Zeitangaben im ISO-Format (ISO 8601).
| # | A | B |
|---|---|---|
| 1 | (\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[1-2][0-9]|3[01])T(?:[0-1][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]) | |
| 2 | ||
| 3 | 2023-11-24T15:30:45 | 2023-11-24T15:30:45 |
| 4 | 2023-13-01T12:00:00 | |
| 5 | 2023-11-31T10:15:00 | 2023-11-31T10:15:00 |
| 6 | 24.11.2023 M15:30:45 | |
| 7 | 2023-08-14T19:10:23 | 2023-08-14T19:10:23 |
Datumswerte in der Google Tabellen Funktion REGEXEXTRACT
Muster: ^(?:[0-2][0-9]|3[01])\.(?:0[1-9]|1[0-2])\.\d{4}$
Beschreibung: Findet Datumsangaben im Format TT.MM.JJJJ, wobei der Tag (1-31) und der Monat (1-12) korrekt geprüft werden.
| # | A | B |
|---|---|---|
| 1 | ^(?:[0-2][0-9]|3[01])\.(?:0[1-9]|1[0-2])\.\d{4}$ | |
| 2 | ||
| 3 | 24.10.2023 | 24.10.2023 |
| 4 | 01.13.2024 | |
| 5 | 32.01.2024 | |
| 6 | 10.05.2025 | 10.05.2025 |
| 7 | 30.02.2023 | 30.02.2023 |
Uhrzeiten in der Google Tabellen Funktion REGEXEXTRACT
Muster: ^(?:[0-1][0-9]|2[0-3]):(?:[0-5][0-9])(?::[0-5][0-9])?$
Beschreibung: Findet Uhrzeiten im 24-Stunden-Format mit optionalen Sekunden.
| # | A | B |
|---|---|---|
| 1 | ^(?:[0-1][0-9]|2[0-3]):(?:[0-5][0-9])(?::[0-5][0-9])?$ | |
| 2 | ||
| 3 | 12:30:45 | 12:30:45 |
| 4 | 23:59 | 23:59 |
| 5 | 12:70 | |
| 6 | 00:00:00 | 00:00:00 |
| 7 | 10:5 |
Zahlen mit 1000er Trennpunkte in der Google Tabellen Funktion REGEXEXTRACT
Muster: \b[1-9][0-9]{0,2}(\.[0-9]{3})*,[0-9]{2}\b
Beschreibung: Findet Zahlen mit Tausendertrennzeichen und zwei Dezimalstellen (deutsche Notation, z. B. 1.234,56).
| # | A | B |
|---|---|---|
| 1 | \b[1-9][0-9]{0,2}(?:\.[0-9]{3})*,[0-9]{2}\b | |
| 2 | ||
| 3 | 1234.56 | 1.234,56 |
| 4 | 12.34 | 12,34 |
| 5 | 23456.78 | |
| 6 | 1000000 | 1.000.000,00 |
| 7 | 0.12 |
Muster: ^\d{1,3}(\.\d{3})*(,\d{2})?$
Beschreibung: Findet deutsche Dezimalzahlen mit optionaler Tausendertrennung.
Da es optional mit dem tausender Trennpunkt ist, kann das auch auf normale Zahlen angewendet werden.
| # | A | B |
|---|---|---|
| 1 | ^\d{1,3}(?:\.?\d{3})*(?:,\d{2})?$ | |
| 2 | ||
| 3 | 1000,23 | 1000,23 |
| 4 | ABC 1000 | |
| 5 | 1000 ABC | |
| 6 | 1000000.45 | 1.000.000,45 |
| 7 | 10.34 | 10,34 |
Muster: ^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})\.(25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})\.(25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})\.(25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})$
Beschreibung: Findet IPv4-Adressen, wobei jede Zahl 0-255 entspricht.
Durch die Klammern wurden Gruppen gebildet die in jeweils einer eigenen Zelle eingetragen werden.
| # | A | B | C | D | E |
|---|---|---|---|---|---|
| 1 | ^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})\.(25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})\.(25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})\.(25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})$ | ||||
| 2 | |||||
| 3 | 192.168.1.1 | 192 | 168 | 1 | 1 |
| 4 | 300.168.1.1 | ||||
| 5 | 0.0.0.0 | 0 | 0 | 0 | 0 |
| 6 | 255.255.255.255 | 255 | 255 | 255 | 255 |
| 7 | 255.255.256.255 | ||||
Damit alles in einer Zelle eingetragen wird, habe ich die Formel etwas abgeändert:
Muster: ^(?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})\.(?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})\.(?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})\.(?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})$
Wie Ihr seht habe ich wieder nach jeder geöffneten Klammer ?: eingesetzt damit die Gruppen nicht gefangen und separat ausgegeben werden 😉
| # | A | B |
|---|---|---|
| 1 | ^(?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})\.(?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})\.(?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})\.(?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})$ | |
| 2 | ||
| 3 | 192.168.1.1 | 192.168.1.1 |
| 4 | 300.168.1.1 | |
| 5 | 0.0.0.0 | 0.0.0.0 |
| 6 | 255.255.255.255 | 255.255.255.255 |
| 7 | 255.255.256.255 | |
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: "REGEXEXTRACT Reguläre Ausdrücke mit vielen Beispielen mit Google Tabellen"