Regex (regulärer Ausdruck) ist ein Suchmuster für Text. Statt nach einem konkreten Wort zu suchen, beschreibst du ein Muster – zum Beispiel „3 Ziffern, Bindestrich, 4 Ziffern“.

Du brauchst Regex, wenn du:

• Suchen willst, ohne den exakten Text zu kennen (z.B. alle Telefonnummern in einem Text)
• Eingaben validieren musst (E-Mail, PLZ, IBAN beim Anmeldeformular)
• Text umformen willst (aus Max Mustermann mach Mustermann, Max)
• Logs analysieren willst (alle Fehlerzeilen mit IP-Adresse finden)

Kurz: Immer wenn du Text nicht 1:1 suchst, sondern nach einem Muster.

Die Schreibweise /muster/flags kommt aus JavaScript und ist eine Kurzschreibweise:

• Schrägstriche /: Umschließen das Muster (damit man Anfang und Ende sieht)
• Buchstaben dahinter: Das sind die Flags (Optionen)

Beispiele:

• /\d+/g — finde alle Zahlen
• /hallo/i — finde "hallo", "Hallo", "HALLO"
• /^start/m — Zeilen, die mit "start" anfangen

In Programmiersprachen schreibt man auch: new RegExp("\\d+", "g"). Der Effekt ist derselbe.

Das sind Kurzschreibweisen für häufige Zeichenklassen:

• \d = digit (Ziffer): 0, 1, 2, ..., 9
• \w = word (Wortzeichen): a-z, A-Z, 0-9 und Unterstrich _
• \s = space (Leerraum): Leerzeichen, Tab, Zeilenumbruch

Mit Großbuchstaben wird die Bedeutung umgekehrt:

• \D = alles außer Ziffern
• \W = alles außer Wortzeichen
• \S = alles außer Leerraum

Eselsbrücke: Kleinbuchstabe = „das Zeichen“, Großbuchstabe = „alles außer dem Zeichen“.

Diese Zeichen sind Quantoren – sie geben an, wie oft etwas vorkommen darf:

• * = 0 bis unendlich Mal („darf auch fehlen“)
• + = 1 bis unendlich Mal („muss mindestens einmal da sein“)
• ? = 0 oder 1 Mal („optional“)

Beispiel mit ab*c:

• findet ac (b fehlt, weil *)
• findet abc (ein b)
• findet abbbc (viele b)

Beispiel mit ab+c:

• findet NICHT ac (mindestens ein b nötig)
• findet abc, abbbc

Sehr wichtig zu verstehen!

• * ist ein Quantor und allein bedeutungslos – er muss sich auf ein Zeichen davor beziehen. a* heißt: „0 oder mehr a“.
• . ist ein Zeichen (beliebiges Zeichen). .* heißt: „0 oder mehr beliebige Zeichen“ – also alles.

Beispiel: Du willst alles zwischen <h1> und </h1> finden:

• Falsch: <h1>*</h1> — Sternchen bezieht sich auf das > davor, matcht nichts Sinnvolles
• Richtig: <h1>.*</h1> — findet die komplette Überschrift

Die 5 häufigsten Ursachen:

• Sonderzeichen nicht escaped: . bedeutet „beliebiges Zeichen“. Für einen echten Punkt: \.
• Kein g-Flag: Ohne g wird nur der erste Treffer gefunden.
• Groß-/Kleinschreibung: Ohne i-Flag wird Hallo und hallo unterschieden.
• Greedy-Matching: .* frisst zu viel. Verwende .*? (lazy).
• Anker fehlen: \d{3} findet auch die ersten 3 Ziffern aus 12345. Mit ^\d{3}$ nur genau 3.

Ein einfacher Regex:

^[^\s@]+@[^\s@]+\.[^\s@]+$

Bedeutung Schritt für Schritt:

• ^ — Zeilenanfang
• [^\s@]+ — irgendwas, das kein Leerzeichen und kein @ ist
• @ — das @-Zeichen
• [^\s@]+ — Domain-Name (wieder kein Leerzeichen/@)
• \. — ein echter Punkt
• [^\s@]+ — Top-Level-Domain
• $ — Zeilenende

Wichtig: Perfekte E-Mail-Validierung mit Regex ist nicht möglich (RFC 5322 ist zu komplex). Der einfache Regex deckt 99% der Fälle ab.

Gruppen mit runden Klammern (...) fassen mehrere Zeichen zusammen und erfassen sie separat.

Beispiel: (\d{4})-(\d{2})-(\d{2})

• Findet 2024-01-15
• Erfasst Gruppe 1: 2024 (Jahr)
• Erfasst Gruppe 2: 01 (Monat)
• Erfasst Gruppe 3: 15 (Tag)

Gruppen kannst du später im Code einzeln abfragen:

match[1] = Jahr, match[2] = Monat, match[3] = Tag.

Es gibt auch non-capturing groups (?:...) – die fassen nur zusammen, erfassen aber nicht.

ReDoS (Regular Expression Denial of Service) entsteht durch verschachtelte Quantoren, die exponentiell Zeit brauchen.

Gefährliche Muster:

• (a+)+b — zwei + hintereinander auf überlappende Zeichen
• (a|a)+b — Alternation mit gleichen Teilen
• (.*a){10} — quantifizierte Gruppe mit .*

Sichere Muster:

• a+b — kein verschachteltes +
• [^a]+ — Zeichenklasse statt (a|b|c)
• Teste kritische Regex immer mit einem ReDoS-Checker

Faustregel: Kein + oder * direkt auf eine Gruppe, die selbst + oder * enthält.

Ja! Regex ist überall präsent:

• VS Code: Strg+F → .*-Symbol aktivieren
• Excel: In „Suchen & Ersetzen“ mit Wildcards (eingeschränkt) oder VBA mit vollem Regex
• Google Sheets: REGEXMATCH, REGEXEXTRACT, REGEXREPLACE
• Notepad++: Strg+H → Suchmodus „Regulärer Ausdruck“
• Linux-Terminal: grep -E, sed -E, awk
• Sublime/Atom: Regex-Suche in allen Editoren
• Browser-Konsole: text.match(/regex/)