REGEXREPLACE Reguläre Ausdrücke mit vielen Beispielen mit Google Tabellen

REGEXREPLACE 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 REGEXEXTRACT 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 bereits die Formel REGEXREPLACE 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 A4 bis A8 könnt Ihr Daten eintragen um das Muster zu testen.
Auf der rechten Seite erfolgen dann die Ausgaben und Ersetzungen die durch das Muster und den Ersetzungstext festgelegt wurden.

HIER DER DOWNLOAD der Vorlage:

Download REGEXREPLACE-DOWNLOADVERSION.xlsx

Download REGEXREPLACE-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 REGEXREPLACE

Die Funktion REGEXREPLACE ersetzt den Teil des Textes der mit dem Muster übereinstimmt und gibt den geänderten Text aus.

REGEXREPLACE(Text; Muster; Ersatztext)

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.
Ersatztext
Ist der Text der anstelle des Originaltextes eingesetzt wird wenn das Muster passt.

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 REGEXREPLACE

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 REGEXREPLACE

Muster: \d
Ersetzung: X
Das Muster \d sucht eine einzelne Ziffer (0–9). Die Ersetzung X ersetzt jede gefundene Ziffer mit einem "X".

#	A	B
1	\d
2	X
3
4	123abc	XXXabc
5	a2c3d4	aXcXdX
6	hello7	helloX
7	abc123	abcXXX
8	9abc8	XabcX

Muster: ^[A-Za-z]
Ersetzung: Z
^[A-Za-z]: Dieses Muster sucht einen einzelnen Buchstaben (A–Z, a–z) am Anfang des Strings.
Der ^-Operator zeigt an, dass es sich um den Anfang des Strings handelt.

#	A	B
1	^[A-Za-z]
2	Z
3
4	abc123	Zbc123
5	Hello7	Zello7
6	xyz	Zyz
7	1abc	1abc
8	AbcDef	ZbcDef

Muster: [A-Za-z]
Ersetzung: Y
Das Muster [A-Za-z] sucht jeden Buchstaben des Alphabets, unabhängig davon, ob es sich um einen Groß- oder Kleinbuchstaben handelt. Die Ersetzung Y ersetzt jeden gefundenen Buchstaben mit einem "Y".

#	A	B
1	[A-Za-z]
2	Y
3
4	Hallo123	YYYYY123
5	42Test	42YYYY
6	ABCdef	YYYYYY
7	!@#hello	!@#YYYYY
8	MixedCase	YYYYYYYYY

Muster: \.$
Ersetzung: !
Das Muster \.$ sucht einen Punkt (.), der sich am Ende eines Strings befindet. Das $ zeigt an, dass das Muster den Abschluss des Strings treffen soll. Die Ersetzung ! ersetzt den gefundenen Punkt mit einem Ausrufezeichen.

#	A	B
1	\.$
2	!
3
4	Das ist ein Test.	Das ist ein Test!
5	Kein Punkt	Kein Punkt
6	Ende.	Ende!
7	.	!
8	12345.	12345!

Muster: \d+
Ersetzung: \$
Das Muster \d+ sucht eine oder mehrere zusammenhängende Ziffern. Das + bedeutet, dass das Muster mindestens eine Ziffer, aber auch eine beliebige Folge von Ziffern trifft. Die Ersetzung \$ ersetzt jede gefundene Zahlenfolge mit einem Dollarzeichen.

#	A	B
1	\d+
2	\$
3
4	123abc456	$abc$
5	Preis: 50	Preis: $
6	42 ist die Zahl	$ ist die Zahl
7	Test1234Test	Test$Test
8	567890	$

Muster: \s{2,}
Ersetzung: " " (Hinweis: Nur ein einzelnes Leerzeichen)
Das Muster \s{2,} sucht nach zwei oder mehr aufeinanderfolgenden Leerzeichen:
\s steht für ein Leerzeichen.
{2,} bedeutet mindestens zwei Leerzeichen hintereinander.
Die Ersetzung ersetzt die gefundenen Leerzeichen durch genau ein einzelnes Leerzeichen.

#	A	B
1	\s{2,}
2
3
4	Dies ist ein Test	Dies ist ein Test
5	Leerzeichen hier	Leerzeichen hier
6	KeinProblem	KeinProblem
7	Viele Leerzeichen	Viele Leerzeichen
8	Start und Ende	Start und Ende

Muster: \\
Ersetzung:
Das Muster \\ sucht nach einem Backslash (\). Da der Backslash als Escape-Zeichen verwendet wird, muss er im Muster selbst maskiert werden. Die Ersetzung "" entfernt alle Backslashes.

#	A	B
1	\\
2
3
4	Pfad\zu\Datei	PfadzuDatei
5	C:\Windows\Test	C:WindowsTest
6	\n\l\t	nlt
7	\
8	OhneBackslash	OhneBackslash

Muster: [^\d]
Ersetzung:
Das Muster [^\d] sucht alles, was keine Ziffer ist. Das ^ innerhalb der eckigen Klammern bedeutet Negation. Die Ersetzung "" entfernt alle nicht-numerischen Zeichen.

#	A	B
1	[^\d]
2
3
4	123abc456	123456
5	Preis: 50 Euro	50
6	42! Ist das die Zahl?	42
7	Test1234Test	1234
8	KeinZahlenwert

Muster: \b
Ersetzung: \|
Das Muster \b steht für eine Wortgrenze (zwischen einem Wort und einem Nicht-Wort-Zeichen). Die Ersetzung | markiert diese Wortgrenzen mit senkrechten Strichen.

#	A	B
1	\b
2	\\|
3
4	Wortgrenzen hier	\|Wortgrenzen\| \|hier\|
5	Preis: 50 Euro	\|Preis\|: \|50\| \|Euro\|
6	42! Ist das die Zahl?	\|42\|! \|Ist\| \|das\| \|die\| \|Zahl\|?
7	Ohne Grenzen	\|Ohne\| \|Grenzen\|
8	Ein-Satz	\|Ein\|-\|Satz\|

Muster: [^a-zA-ZäöüÄÖÜß]
Ersetzung:
Das Muster [a-zA-ZäöüÄÖÜß] berücksichtigt alle Buchstaben des deutschen Alphabets, einschließlich der Umlaute und des ß. Das [^…] negiert die Auswahl, sodass alle nicht-Buchstaben entfernt werden. Die Ersetzung "" löscht alle nicht-Buchstaben.

#	A	B
1	[^a-zA-ZäöüÄÖÜß]
2
3
4	Hallo123! Wie geht's?	HalloWiegehts
5	Grüß Gott!	GrüßGott
6	Das ist 1 Test.	DasistTest
7	Schön, oder?	Schönoder
8	%&§ Sonderzeichen	Sonderzeichen

Muster: [^a-zA-ZäöüÄÖÜß0-9]
Ersetzung:
Das Muster [^a-zA-ZäöüÄÖÜß0-9] sucht alle Zeichen, die keine Buchstaben oder Ziffern sind:
[^a-zA-ZäöüÄÖÜß0-9] steht für Buchstaben (Groß- und Kleinschreibung) und Zahlen.
^ innerhalb der Klammern negiert das Muster.
Die Ersetzung durch Nichts entfernt alle nicht-alphanumerischen Zeichen.

#	A	B
1	[^a-zA-ZäöüÄÖÜß0-9]
2
3
4	Hallo! Wie geht's?	HalloWiegehts
5	Test123-Test äöü	Test123Testäöü
6	$%^&Sonderzeichen123	Sonderzeichen123
7	Leerzeichen auch weg	Leerzeichenauchweg
8	#@!

Muster: \d+([.,]\d+)?
Ersetzung: {Zahl}
Das Muster \d+([.,]\d+)? berücksichtigt Zahlen im deutschen Format:
\d+ sucht eine oder mehrere Ziffern (den Hauptteil der Zahl).
([.,]\d+)? berücksichtigt optional einen Dezimalpunkt oder ein Komma mit weiteren Ziffern.
Die Ersetzung {Zahl} ersetzt jede gefundene Zahl mit {Zahl}.

#	A	B
1	\d+([.,]\d+)?
2	\{Zahl\}
3
4	Preis: 12,34 Euro	Preis: {Zahl} Euro
5	1234.56	{Zahl},{Zahl}
6	Ein Betrag von 12,20 und 15,99	Ein Betrag von {Zahl} und {Zahl}
7	Kein Wert	Kein Wert
8	Betrag: 1000,50 €	Betrag: {Zahl} €

Mittelschwere Beispiele für die Google Tabellen Funktion REGEXREPLACE

Muster: <[^>]+>
Ersetzung:
Das Muster <[^>]+> sucht nach HTML-Tags:
< beginnt das Muster. [^>]+ sucht eine beliebige Zeichenfolge, die kein > enthält.
> beendet das Muster.

#	A	B
1	<[^>]+>
2
3
4	<b>Fett</b>	Fett
5	<div>Inhalt</div>	Inhalt
6	Kein HTML	Kein HTML
7	<p class="Test">Absatz</p>	Absatz
8	<a href="#">Link</a>	Link

Muster: [a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}
Ersetzung: $E-Mail$
Das Muster [a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,} sucht nach gültigen E-Mail-Adressen:
[a-zA-Z0-9._%+-]+ sucht den lokalen Teil der E-Mail (vor dem @).
@[a-zA-Z0-9.-]+ sucht den Domain-Namen nach dem @.
\.[a-zA-Z]{2,} sucht die Top-Level-Domain (mindestens 2 Buchstaben).

#	A	B
1	[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}
2	$E-Mail$
3
4	Kontakt: test@example.com	Kontakt: (E-Mail)
5	user1@mail.de und user2@domain.org	(E-Mail) und (E-Mail)
6	Keine E-Mail hier	Keine E-Mail hier
7	Mail: support@web.co	Mail: (E-Mail)
8	Email test@invalid.	Email test@invalid.

Muster: \d{1,3}([.,]\d{3})+(,\d+|\.\d+|)?
Ersetzung: \{Zahl\}
Das Muster \d{1,3}([.,]\d{3})+(,\d+|\.\d+|)? erkennt Zahlen, die Tausendertrennungen enthalten (z. B. 1.000 oder 1,000.00), und ersetzt sie durch einen Text im Format {Zahl}.
\d{1,3}: Sucht ein bis drei Ziffern zu Beginn.
([.,]\d{3})+: Erfordert mindestens eine Tausendergruppe (z. B. ,123 oder .123).
(,\d+|\.\d+|)?: Optional können Dezimalstellen folgen.
Reine lange Zahlen ohne Tausendertrennungen (z. B. 10000) werden ignoriert.

#	A	B
1	\d{1,3}([.,]\d{3})+(,\d+\|\.\d+\|)?
2	\{Zahl\}
3
4	1000000000000	1000000000000
5	Tausender: 12.345.678	Tausender: {Zahl}
6	Nur 44123,33 hier	Nur 44123,33 hier
7	Keine Zahl	Keine Zahl
8	Wert: 1,234	Wert: {Zahl}

Muster: \+49\s?\d{3,4}[-\s]?\d{4,}
Ersetzung: \{Telefon\}
Das Muster \+49\s?\d{3,4}[-\s]?\d{4,} sucht nach deutschen Telefonnummern im internationalen Format:
\+49 sucht die Vorwahl für Deutschland.
\s? erlaubt ein optionales Leerzeichen.
\d{3,4} sucht 3–4 Ziffern (Ortsvorwahl).
[-\s]? erlaubt einen optionalen Bindestrich oder ein Leerzeichen.
\d{4,} sucht mindestens 4 Ziffern (Teilnehmernummer).
Hinweis: Beim Eintragen von Zahlen in der Art +49 123 4567890 sollte man ein Hochkomma ' voranstellen, damit es direkt als Text erkannt wird.

#	A	B
1	\+49\s?\d{3,4}[-\s]?\d{4,}
2	\{Telefon\}
3
4	+49 123 4567890	{Telefon}
5	Rufnummer: +49 123 4567	Rufnummer: {Telefon}
6	Keine Nummer hier	Keine Nummer hier
7	+49 123-4566	{Telefon}
8	Tel: +4912345678	Tel: {Telefon}

Muster: ([A-Za-zäöüÄÖÜß]+),\s([A-Za-zäöüÄÖÜß]+)
Ersetzung: $2 $1
Das Muster ([A-Za-zäöüÄÖÜß]+),\s([A-Za-zäöüÄÖÜß]+) sucht nach Namen im Format "Nachname, Vorname":
([A-Za-zäöüÄÖÜß]+) sucht den Nachnamen und speichert ihn in Gruppe 1.
,\s erwartet ein Komma, gefolgt von einem Leerzeichen.
([A-Za-zäöüÄÖÜß]+) sucht den Vornamen und speichert ihn in Gruppe 2.
Die Ersetzung $2 $1 formatiert den Namen ins Format "Vorname Nachname".

#	A	B
1	([A-Za-zäöüÄÖÜß]+),\s([A-Za-zäöüÄÖÜß]+)
2	$2 $1
3
4	Müller, Max	Max Müller
5	Schmidt, Anna	Anna Schmidt
6	Kein Name hier	Kein Name hier
7	Mustermann, Erika	Erika Mustermann
8	Meier, Hans und Müller, Lisa	Hans Meier und Lisa Müller

Komplexere Beispiele für die Google Tabellen Funktion REGEXREPLACE

Muster: (\d{1,2}).(\d{1,2}).(\d{4})
Ersetzung: $3-$2-$1
Das Muster (\d{1,2})\.(\d{1,2})\.(\d{4}) sucht nach Datumsangaben im deutschen Format (TT.MM.JJJJ):
(\d{1,2}) sucht 1–2 Ziffern für den Tag und speichert sie in einer Capturing Group (Gruppe 1).
\. sucht den Punkt als Trennzeichen.
(\d{1,2}) sucht 1–2 Ziffern für den Monat und speichert sie in Gruppe 2.
\.(\d{4}) sucht genau 4 Ziffern für das Jahr und speichert sie in Gruppe 3.
Die Ersetzung $3-$2-$1 wandelt das Datum ins ISO-Format (JJJJ-MM-TT) um.

#	A	B
1	(\d{1,2}).(\d{1,2}).(\d{4})
2	$3-$2-$1
3
4	Datum: 25.12.2023	Datum: 2023-12-25
5	Am 24.01.2024 einen Termin	Am 2024-01-24 einen Termin
6	Termin: 15.08.1999	Termin: 1999-08-15
7	Kein Datum hier	Kein Datum hier
8	31.03.2000 und 13.4.2020	2000-03-31 und 2020-4-13

Muster: (https?://)([a-zA-Z0-9.-]+)(/[^\s]*)?
Ersetzung: $1[DOMAIN]$3
Das Muster (https?:\/\/)([a-zA-Z0-9.-]+)(\/[^\s]*)? sucht nach URLs:
(https?:\/\/) sucht nach dem Protokoll (http:// oder https://) und speichert es in Gruppe 1.
([a-zA-Z0-9.-]+) sucht den Domainnamen und speichert ihn in Gruppe 2.
(\/[^\s]*)? sucht optional nach einem Pfad hinter dem Domainnamen und speichert ihn in Gruppe 3.
Die Ersetzung $1[DOMAIN]$3 anonymisiert die Domain, behält aber das Protokoll und den Pfad.

#	A	B
1	(https?://)([a-zA-Z0-9.-]+)(/[^\s]*)?
2	$1[DOMAIN]$3
3
4	https://example.com	https://[DOMAIN]
5	http://test.de/path/to/page	http://[DOMAIN]/path/to/page
6	Kein Link hier	Kein Link hier
7	https://sub.domain.org/test	https://[DOMAIN]/test
8	http://localhost:8080	http://[DOMAIN]:8080

Muster: (\d{3})-(\d{1,5})-(\d{1,7})-(\d{1,7})-(\d{1})
Ersetzung: ISBN: $1-$2-$3-$4-$5
Das Muster (\d{3})-(\d{1,5})-(\d{1,7})-(\d{1,7})-(\d{1}) sucht nach ISBN-Nummern im Format XXX-X-XXXXX-XXXX-X:
(\d{3}) sucht die ersten 3 Ziffern der ISBN und speichert sie in Gruppe 1.
(\d{1,5}), (\d{1,7}), (\d{1,7}) und (\d{1}) suchen die nachfolgenden Teile der ISBN mit jeweils spezifischen Längen.
Die Ersetzung ISBN: $1-$2-$3-$4-$5 fügt den Präfix "ISBN: " hinzu und formatiert die Nummer korrekt.

#	A	B
1	(\d{3})-(\d{1,5})-(\d{1,7})-(\d{1,7})-(\d{1})
2	ISBN: $1-$2-$3-$4-$5
3
4	978-3-16-148410-0	ISBN: 978-3-16-148410-0
5	ISBN: 978-0-393-04002-9	ISBN: ISBN: 978-0-393-04002-9
6	Keine ISBN	Keine ISBN
7	Text 12345623452345345345	Text 12345623452345345345
8	978-0-7432-7356-5 und 978-0-596-52068-7	ISBN: 978-0-7432-7356-5 und ISBN: 978-0-596-52068-7

Muster: (\w{4})(\w{4})(\w{4})(\w{4})(\w{0,})
Ersetzung: $1 $2 $3 $4 $5
Das Muster (\w{4})(\w{4})(\w{4})(\w{4})(\w{0,}) sucht nach einer IBAN-Nummer ohne Leerzeichen:
(\w{4}) sucht nach 4 alphanumerischen Zeichen und speichert sie in einer Gruppe.
Wiederholungen davon gruppieren jeweils 4 weitere Zeichen.
(\w{0,}) nimmt den Rest der Zeichen (z. B. 2 bei DE-IBANs).
Die Ersetzung fügt zwischen den Gruppen Leerzeichen ein, um die Lesbarkeit zu verbessern.

#	A	B
1	(\w{4})(\w{4})(\w{4})(\w{4})(\w{0,})
2	$1 $2 $3 $4 $5
3
4	DE89370400440532013000	DE89 3704 0044 0532 013000
5	FR1420041010050500013M02606	FR14 2004 1010 0505 00013M02606
6	Kein IBAN	Kein IBAN
7	ES9121000418450200051332	ES91 2100 0418 4502 00051332
8	CH9300762011623852957	CH93 0076 2011 6238 52957

Muster: \b[a-fA-F0-9]{32}\b|\b[a-fA-F0-9]{64}\b
Ersetzung: [HASH]
Das Muster \b[a-fA-F0-9]{32}\b|\b[a-fA-F0-9]{64}\b sucht nach Hashes mit einer Länge von 32 (MD5) oder 64 (SHA256) Zeichen:
[a-fA-F0-9]{32} sucht nach einer 32-stelligen Hexadezimal-Zeichenkette.
| erlaubt eine Alternative (entweder 32 oder 64 Zeichen).
[a-fA-F0-9]{64} sucht nach einer 64-stelligen Hexadezimal-Zeichenkette.
\b stellt sicher, dass der Hash an einer Wortgrenze beginnt und endet.
Die Ersetzung [HASH] anonymisiert alle gefundene Hashes.

#	A	B
1	\b[a-fA-F0-9]{32}\b\|\b[a-fA-F0-9]{64}\b
2	\[HASH\]
3
4	MD5: d41d8cd98f00b204e9800998ecf8427e	MD5: [HASH]
5	SHA256: 9d5ed678fe57bcca610140957afab5712ed7e1fa18f69d67bbf6c3e589d4f911	SHA256: [HASH]
6	Kein Hash hier	Kein Hash hier
7	Test d41d8cd98f00b204e9800998ecf8427e Test	Test [HASH] Test
8	SHA512: (nicht erfasst)	SHA512: (nicht erfasst)

Muster: (\d{5})\s([A-Za-zäöüÄÖÜß\s-]+)
Ersetzung: PLZ: $1, Ort: $2
Das Muster (\d{5})\s([A-Za-zäöüÄÖÜß\s-]+) sucht nach einer Postleitzahl (PLZ) und einem Ortsnamen:
(\d{5}) sucht genau 5 Ziffern für die PLZ und speichert sie in Gruppe 1.
\s erwartet ein Leerzeichen.
([A-Za-zäöüÄÖÜß\s-]+) sucht den Ortsnamen, bestehend aus Buchstaben, Leerzeichen und Bindestrichen, und speichert ihn in Gruppe 2.
Die Ersetzung PLZ: $1, Ort: $2 formatiert die extrahierten Werte in ein beschreibendes Format.

#	A	B
1	(\d{5})\s([A-Za-zäöüÄÖÜß\s-]+)
2	PLZ: $1, Ort: $2
3
4	10115 Berlin	PLZ: 10115, Ort: Berlin
5	80331 München	PLZ: 80331, Ort: München
6	Hamburg ohne PLZ	Hamburg ohne PLZ
7	50667 Köln	PLZ: 50667, Ort: Köln
8	01067 Dresden und 01109 Klotzsche	PLZ: 01067, Ort: Dresden und PLZ: 01109, Ort: Klotzsche

Datumswerte in der Google Tabellen Funktion REGEXREPLACE

Muster: \b\d{2}.\d{2}.\d{4}\b
Ersetzung: {Datum}
Das Muster \b\d{2}\.\d{2}\.\d{4}\b sucht nach Datumsangaben im Format "TT.MM.JJJJ":
\d{2} sucht genau zwei Ziffern für den Tag.
\. erwartet den Punkt als Trennzeichen.
\d{2} sucht genau zwei Ziffern für den Monat.
\. erwartet den nächsten Punkt.
\d{4} sucht genau vier Ziffern für das Jahr.
Die Ersetzung {Datum} markiert jedes gefundene Datum im Text.

#	A	B
1	\b\d{2}\.\d{2}\.\d{4}\b
2	\{Datum\}
3
4	Wed Jan 01 2025 00:00:00 GMT+0100 (Mitteleuropäische Normalzeit)	{Datum}
5	Test am 31.04.2025	Test am {Datum}
6	Kein Datum hier	Kein Datum hier
7	31.09.2024 Termin	{Datum} Termin
8	01.01.2023 und 31.12.2024	{Datum} und {Datum}

Muster: \b(\d{2}).(\d{2}).(\d{4})\b
Ersetzung: Datum: $1.$2.$3
(\d{2}): Capturing Group 1 speichert den Tag (2 Ziffern).
\.: Sucht den Punkt als Trennzeichen.
(\d{2}): Capturing Group 2 speichert den Monat (2 Ziffern).
\.: Sucht den zweiten Punkt.
(\d{4}): Capturing Group 3 speichert das Jahr (4 Ziffern).
Über $1.$2.$3 wird das Datum aus den Capturing Groups in der gleichen Reihenfolge wieder ausgegeben.

#	A	B
1	\b(\d{2})\.(\d{2})\.(\d{4})\b
2	Datum: $1.$2.$3
3
4	01.01.2025	Datum: 01.01.2025
5	Test am 31.04.2025	Test am Datum: 31.04.2025
6	Kein Datum hier	Kein Datum hier
7	31.09.2024 Termin	Datum: 31.09.2024 Termin
8	01.01.2023 und 31.12.2024	Datum: 01.01.2023 und Datum: 31.12.2024

Uhrzeiten in der Google Tabellen Funktion REGEXREPLACE

Muster: \b\d{2}:\d{2}\b
Ersetzung: {Uhrzeit}
Das Muster \b\d{2}:\d{2}\b sucht nach Uhrzeiten im Format "HH:MM":
\d{2} sucht genau zwei Ziffern für die Stunde.
: erwartet den Doppelpunkt.
\d{2} sucht genau zwei Ziffern für die Minuten.
Die Ersetzung {Uhrzeit} markiert jede gefundene Uhrzeit.
Hinweis: In Zelle A5 wurde die Zahl so eingetragen: '14:30:00 damit sie als Text formatiert wird und korrekt mit dem Muster funktioniert.

#	A	B
1	\b\d{2}:\d{2}\b
2	\{Uhrzeit\}
3
4	14:30:00	{Uhrzeit}:00
5	Startzeit: 08:15	Startzeit: {Uhrzeit}
6	Kein Zeitwert hier	Kein Zeitwert hier
7	23:59 und 00:00	{Uhrzeit} und {Uhrzeit}
8	Keine korrekte Uhrzeit: 25:61	Keine korrekte Uhrzeit: {Uhrzeit}

Muster: \b(\d{2}):(\d{2})\b
Ersetzung: Uhrzeit: $1:$2
(\d{2}): Capturing Group 1 speichert die Stunden (2 Ziffern).
: Sucht den Doppelpunkt.
(\d{2}): Capturing Group 2 speichert die Minuten (2 Ziffern).
Die Ersetzung Uhrzeit: $1:$2 gibt die Uhrzeit im Format "HH:MM" aus.

#	A	B
1	\b(\d{2}):(\d{2})\b
2	Uhrzeit: $1:$2
3
4	14:30:00	Uhrzeit: 14:30:00
5	Startzeit: 08:15	Startzeit: Uhrzeit: 08:15
6	Kein Zeitwert hier	Kein Zeitwert hier
7	23:59:00 und 00:00:00	Uhrzeit: 23:59:00 und Uhrzeit: 00:00:00
8	Keine korrekte Uhrzeit: 25:61	Keine korrekte Uhrzeit: Uhrzeit: 25:61

Muster: \b\d{2}\.\d{2}\.\d{4}\s\d{2}:\d{2}\b
Ersetzung: \{DatumUhrzeit\}
Das Muster \b\d{2}\.\d{2}\.\d{4}\s\d{2}:\d{2}\b sucht nach Kombinationen aus Datum und Uhrzeit:
\d{2}\.\d{2}\.\d{4} sucht ein Datum im Format "TT.MM.JJJJ".
\s erwartet ein Leerzeichen zwischen Datum und Uhrzeit.
\d{2}:\d{2} sucht eine Uhrzeit im Format "HH:MM".
Die Ersetzung {DatumUhrzeit} markiert jede gefundene Kombination.

#	A	B
1	\b\d{2}\.\d{2}\.\d{4}\s\d{2}:\d{2}\b
2	\{DatumUhrzeit\}
3
4	01.01.2024 12:30	{DatumUhrzeit}
5	Start: 25.12.2023 18:45	Start: {DatumUhrzeit}
6	Kein Datum hier	Kein Datum hier
7	31.12.2024 23:59 und 01.01.2025 00:00	{DatumUhrzeit} und {DatumUhrzeit}
8	Ungültig: 30.02.2023 25:00	Ungültig: {DatumUhrzeit}

Muster: \b(\d{2})\.(\d{2})\.(\d{4})\s(\d{2}):(\d{2})\b
Ersetzung: Datum: $1.$2.$3, Uhrzeit: $4:$5
(\d{2})\.(\d{2})\.(\d{4}): Capturing Groups 1, 2 und 3 speichern Tag, Monat und Jahr.
\s: Erwartet ein Leerzeichen zwischen Datum und Uhrzeit.
(\d{2}):(\d{2}): Capturing Groups 4 und 5 speichern die Stunden und Minuten.
Die Ersetzung Datum: $1.$2.$3, Uhrzeit: $4:$5 gibt sowohl Datum als auch Uhrzeit aus.

#	A	B
1	\b(\d{2})\.(\d{2})\.(\d{4})\s(\d{2}):(\d{2})\b
2	Datum: $1.$2.$3, Uhrzeit: $4:$5
3
4	01.01.2024 12:30	Datum: 01.01.2024, Uhrzeit: 12:30
5	Start: 25.12.2023 18:45	Start: Datum: 25.12.2023, Uhrzeit: 18:45
6	Kein Datum hier	Kein Datum hier
7	31.12.2024 23:59 und 01.01.2025 00:00	Datum: 31.12.2024, Uhrzeit: 23:59 und Datum: 01.01.2025, Uhrzeit: 00:00
8	Ungültig: 30.02.2023 25:00	Ungültig: Datum: 30.02.2023, Uhrzeit: 25:00

Zahlen mit 1000er Trennpunkte in der Google Tabellen Funktion REGEXREPLACE

Muster: \b\d{1,3}(?:\.\d{3})+(?:,\d{2})?\b
Ersetzung: \{Zahl\}
\b\d{1,3}: Sucht nach 1–3 Ziffern am Anfang.
(?:\.\d{3})+:
Erlaubt mindestens einen Tausendertrennungspunkt mit exakt drei Ziffern.
Das + stellt sicher, dass es sich um mindestens eine Tausendergruppe handelt.
(?:,\d{2})?:
Optional: Ein Komma gefolgt von genau zwei Nachkommastellen.
\b: Markiert die Wortgrenzen, um vollständige Zahlen zu erkennen.
Hinweis: Warum ist in Zelle B5 noch ,9. Das hängt damit zusammen dass die Nachkommastelle zweistellig sein muss. Trotzdem ergibt der Teil davor eine komplette Zahl (eben ohne Nachkommastellen). Übrig bleibt dann nur noch ,9.

#	A	B
1	\b\d{1,3}(?:\.\d{3})+(?:,\d{2})?\b
2	\{Zahl\}
3
4	1.234,56	{Zahl}
5	12.345.678,9	{Zahl},9
6	123456 ohne Punkt	123456 ohne Punkt
7	1.000 und 100,00	{Zahl} und 100,00
8	Ungültig: 1.23.456	Ungültig: 1.{Zahl}

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.