Regex-Kurs

Die Grundlagen regulärer Ausdrücke: Literale Muster, Basis-Zeichenklassen, das Jokerzeichen `.` und das Maskieren (Escaping) von Metazeichen.

1. 1.1Literale MusterNormale Zeichen, Groß-/Kleinschreibung und die erste Ausführung: Match und Index.~8 Min
2. 1.2Basisklassen: \d \w \sVordefinierte Klassen für Ziffern, Wortzeichen und Leerzeichen (sowie deren negierte Versionen).~10 Min
3. 1.3Der Platzhalter: Der Punkt `.`Das Zeichen `.` matcht fast alles: Was enthalten ist, was nicht und warum das `s`-Flag benötigt wird.~8 Min
4. 1.4Maskierung von MetazeichenDie 12 Metazeichen, die mit `\` maskiert werden müssen, wann ein doppelter Backslash nötig ist und warum.~10 Min

Wie oft wiederholen: `*`, `+`, `?`, Bereiche `{n,m}` und der Unterschied zwischen Greedy und Lazy.

1. 2.1`*`, `+`, `?`Null oder mehr, eins oder mehr, optional: Die drei Basis-Quantifizierer.~10 Min
2. 2.2Genaue Mengen `{n,m}`Exakt `n`-mal, von `n` bis `m`-mal, mindestens `n`-mal: Der numerische Quantifizierer.~10 Min
3. 2.3Greedy vs. LazyStandardmäßig sind Quantifizierer gierig (`.*`); füge `?` für die faule Version hinzu (`.*?`).~10 Min
4. 2.4Backtracking: GrundlagenWas die Regex-Engine tut, wenn ein gieriger Quantifizierer scheitert, und warum das teuer werden kann.~12 Min

Position, kein Zeichen: Verankern am Anfang/Ende des Strings, an Wortgrenzen und am Anfang/Ende jeder Zeile mit dem `m`-Flag.

1. 3.1Anfang und Ende: `^` und `$`Verankern eines Musters auf das erste oder letzte Zeichen des Strings.~8 Min
2. 3.2Wortgrenzen: `\b` `\B`Der Übergang zwischen Wort- und Nicht-Wortzeichen; Finden ganzer Wörter.~10 Min
3. 3.3`m`-Flag: MultilineMit dem `m`-Flag verankern sich `^` und `$` am Anfang/Ende jeder Zeile.~10 Min
4. 3.4Leere Zeilen und TrimNützliche Muster: Leere Zeilen matchen, Leerzeichen am Anfang/Ende einer Zeile entfernen.~10 Min

Gruppieren mit `()`, Wählen zwischen Alternativen mit `|`, Vermeiden der Erfassung mit `(?:...)`, Benennen von Gruppen mit `(?<nome>...)` und Referenzieren erfasster Gruppen mit Backreferences.

1. 4.1Erfassungsgruppen: `(...)`Runde Klammern zum Gruppieren und Erfassen; Zugriff auf die Gruppen 1, 2, 3… im Match.~10 Min
2. 4.2Alternativen: `|`Die Pipe zum Wählen zwischen zwei oder mehr Untermustern; Rangfolge und Klammern.~10 Min
3. 4.3Nicht-erfassende Gruppen: `(?:...)`Gruppieren ohne Erfassung: Nützlich für Quantifizierung oder Alternativen.~10 Min
4. 4.4Benannte Gruppen und Rückwärtsreferenzen`(?<nome>...)` zur Benennung; `\1` `\k<nome>` zur Referenzierung der erfassten Gruppe.~12 Min

Definieren eigener Zeichenmengen mit `[...]`, Verwenden von Bereichen, Negieren mit `[^...]` und Verwenden von Unicode-Eigenschaften mit `\p{...}` und dem `u`-Flag.

1. 5.1Zeichenmengen: `[abc]`Eckige Klammern zur Definition einer Menge erlaubter Zeichen an einer Position.~8 Min
2. 5.2Bereiche in Klassen: `[a-z0-9]`Intervalle mit Bindestrich; Kombinieren von Bereichen und Einzelzeichen.~8 Min
3. 5.3Negation: `[^...]`Eine negierte Klasse matcht alles außer den aufgelisteten Zeichen.~8 Min
4. 5.4Unicode Property Escapes`\p{L}`, `\p{N}`, `\p{Script=...}` mit `u`-Flag: Unicode-Semantikklassen.~12 Min

Nullbreiten-Behauptungen: Vorwärts oder rückwärts im String blicken, ohne Zeichen zu konsumieren. Lookahead `(?=)` `(?!)`, Lookbehind `(?<=)` `(?<!)`.

1. 6.1Positives Lookahead: `(?=...)`Prüft, ob der aktuellen Position ein bestimmtes Muster folgt, ohne es zu konsumieren.~10 Min
2. 6.2Negatives Lookahead: `(?!...)`Prüft, ob der aktuellen Position ein bestimmtes Muster NICHT folgt.~10 Min
3. 6.3Lookbehind: `(?<=...)` `(?<!...)`Die „Rückwärts-Versionen“ der Lookarounds; unterstützt ab ES2018+.~12 Min
4. 6.4Lookaround in der PraxisEinen Wert extrahieren, ohne den Kontext einzuschließen, Passwörter validieren, begrenzte Zahlen parsen.~12 Min

Alle Flags (inklusive `d`, `v`), `String.prototype.replace`/`replaceAll`/`split` mit Regex, Referenzen `$1`/`$<nome>` im Ersetzungsstring und Ersetzungs-Callbacks.

1. 7.1Alle Flags im Detail`g i m s u v y d`: Was jedes Flag tut und wie sie kombiniert werden.~12 Min
2. 7.2Einfache Ersetzung und `$1`Ersetzen von Matches durch feste Strings oder Backreferences `$1` / `$<nome>`.~10 Min
3. 7.3Ersetzung mit CallbackErsetzungsfunktion: Transformieren jedes Matches mit beliebigem JS-Code, Zugriff auf Gruppen.~12 Min
4. 7.4Split mit RegexAufteilen eines Strings anhand eines Musters (tolerantes CSV, einfacher Tokenizer).~10 Min

Anwenden des Wissens auf reale Probleme: Validieren von E-Mails, Parsen von Logs, Extrahieren von URLs/IPs und Schreiben ReDoS-sicherer Muster.

1. 8.1E-Mail validierenEin „gut genug“ Muster für E-Mails mit Erklärung der Kompromisse.~12 Min
2. 8.2Apache-Log-ParserExtraktion von IP, Methode, Pfad und Statuscode aus einer Logzeile mittels benannter Gruppen.~12 Min
3. 8.3URLs und IPs extrahierenErkennen von http(s)-URLs und IPv4-Adressen in freiem Text.~12 Min
4. 8.4ReDoS-sichere Muster schreibenErkennen katastrophaler Muster (`(a+)+b`), deren Refaktorisierung, Verwendung atomarer Quantifizierer-Äquivalente.~14 Min