Reguläre Ausdrücke live testen, Matches hervorheben und Ersetzungen vorschauen.
{{ replaceResult }}| # | Treffer | Index | Gruppen |
|---|---|---|---|
| {{ i + 1 }} | {{ m.value }} |
{{ m.index }} | — ${{ gi + 1 }}: {{ g ?? 'undefined' }} |
{{ item.token }} |
{{ item.desc }} |
Reguläre Ausdrücke (RegEx) sind leistungsstarke Suchmuster, die in der Textverarbeitung und Programmierung eingesetzt werden. Sie ermöglichen es, komplexe Zeichenfolgen-Muster zu definieren, um Text zu suchen, zu validieren, zu extrahieren oder zu ersetzen. Fast jede Programmiersprache — von JavaScript über Python bis PHP — unterstützt reguläre Ausdrücke.
RegEx wird für E-Mail-Validierung, Telefonnummern-Erkennung, URL-Parsing, Log-Analyse, Datenextraktion aus HTML, Suchen-und-Ersetzen in Code-Editoren und vieles mehr verwendet. Unser Online-RegEx-Tester nutzt die JavaScript-RegExp-Engine, sodass du Muster direkt im Browser testen kannst.
*?, +?) wenn du den kürzesten Match brauchst.(), um Teile des Matches zu extrahieren und in Ersetzungen zu verwenden.(a+)+ können zu katastrophalem Backtracking führen.Eine RegEx (regular expression) ist ein formaler Beschreibung einer Sprachklasse, die ein Endlicher Automat (NFA oder DFA) erkennen kann. Praktisch alle Mainstream-Engines — V8 (JavaScript), PCRE (PHP, Perl), RE2 (Go, Rust), .NET Regex, Java java.util.regex — verwenden eine NFA-Backtracking-Engine, die Tokens des Patterns sequentiell gegen die Eingabe matcht. Die JavaScript-Engine implementiert das ECMA-262 RegExp-Subset, das im Vergleich zu PCRE einige Features auslaesst: keine Possessive Quantifier a++, keine Atomic Groups (?>abc), keine relativen Backreferences. Wer Patterns zwischen PHP und JS portiert, stolpert exakt darueber.
Beim Matching probiert die Engine systematisch alle Moeglichkeiten durch. Bei a.*b auf der Eingabe aXXXb liest der Greedy-Quantifier .* erstmal alles bis zum Ende und backtrackt dann Zeichen fuer Zeichen, bis das b matcht. Genau das ist die Achillesferse: bestimmte Patterns wie (a+)+$ auf aaaaaaaaaaaaaaaab erzeugen exponentielle Backtracking-Pfade, was als katastrophisches Backtracking bekannt ist und schon CPU-Lockups in Production-Systemen ausgeloest hat (CVE-2019-12041, der beruehmte Cloudflare-Outage von 2019 war genau das). Schutz: Lazy Quantifier (a+?)+ oder Atomic Groups (in PCRE), oder ein Wechsel zu RE2-basierten Engines wie Hyperscan, die linear-time-Garantie bieten.
Capturing Groups (abc) merken sich das gematchte Substring fuer Backreferences \1 oder fuer den Replace-Ausdruck $1. Non-Capturing Groups (?:abc) machen das gleiche ohne den Speicher-Overhead — die Engine muss intern nichts merken. Lookarounds (?=...) (positive Lookahead) und (?<=...) (positive Lookbehind) sind zero-width-Assertions: sie pruefen, dass eine Position einem Pattern entspricht, ohne Zeichen zu konsumieren. ECMA-262 unterstuetzt Lookbehind seit ES2018 — vorher war das ein JS-spezifischer Pain Point. Named Groups (?<name>abc) sind seit ES2018 ebenfalls verfuegbar und liefern match.groups.name.
Diese Token decken die Mehrheit aller Patterns ab, die in REST-APIs, Validierungen und Log-Parsern vorkommen.
\d Ziffer, \w Wortzeichen [A-Za-z0-9_], \s Whitespace, Grossschreibung negiert (\D, \W, \S).* 0+, + 1+, ? 0/1, {3} exakt 3, {2,5} 2 bis 5. Mit ? dahinter werden sie lazy: .*?.^ Zeilenanfang, $ Zeilenende, \b Wortgrenze. Im Multiline-Modus matchen ^ und $ bei jedem \n.(abc) capturing, (?:abc) non-capturing, (?<name>abc) named, a|b Alternation.(?=...) positiv lookahead, (?!...) negativ lookahead, (?<=...) positiv lookbehind, (?<!...) negativ lookbehind.Diese Ausdruecke decken haeufige Validierungs- und Parsing-Aufgaben ab. Bitte testen — Email-Validierung per Regex ist beruechtigt brueechig, fuer Produktion lieber dedizierte Libraries.
^[A-Z][a-zA-Z0-9]*$ matcht PascalCase-Identifier (FooBar, HTTPClient), nicht foo oder 123Bar.^\d{4}-\d{2}-\d{2}$ validiert grob ein ISO-Datum (2024-06-09) — eine vollstaendige Validierung erfordert Pruefung auf gueltige Tageszahl.\b(?:\d{1,3}\.){3}\d{1,3}\b findet IPv4-Adressen in Texten. Strenger waere (?:25[0-5]|2[0-4]\d|[01]?\d?\d) pro Oktett.(?<=\?)[^&]+(?=&|$) extrahiert den ersten Query-Parameter-Wert aus einer URL ohne den vorherigen ?.^(?=.*[A-Z])(?=.*\d)(?=.*[^A-Za-z0-9]).{12,}$ akzeptiert nur Passwoerter mit mindestens 12 Zeichen, einer Grossbuchstaben, einer Ziffer, einem Sonderzeichen.Erster Grenzpunkt: Backtracking. Patterns wie (a+)+b oder (a|aa)*b brauchen auf Input ohne b exponentielle Zeit — typischer Vektor fuer ReDoS (Regular Expression Denial of Service). Vor Production-Einsatz auf Worst-Case-Input testen, oder den Re2-Backend (Go, Rust) bevorzugen. Zweiter Punkt: Unicode. \w matcht in JavaScript ohne u-Flag nur ASCII-Wortzeichen, deutsche Umlaute fallen raus. Mit /pattern/u aendert sich das Verhalten, dafuer sind Surrogate Pairs richtig behandelt. PCRE braucht den u-Modifier explizit. Dritter Punkt: . matcht standardmaessig kein Newline. Im DOTALL-/s-Flag tut es das, was bei Multi-Line-Logs gewollt ist. Vierter Punkt: gierige vs. lazy. <.*> auf <a>text</a> matcht das ganze <a>text</a>, weil .* greedy ist. Mit <.*?> bekommst du nur <a>. Fuenfter Punkt: HTML mit Regex parsen ist Anti-Pattern — die Sprache ist nicht regulaer. Fuer HTML/XML einen echten Parser nutzen, fuer JSON JSON.parse.
*, +, ?, {n,m}) versuchen so viele Zeichen wie moeglich zu matchen und backtracken nur, wenn der Rest des Patterns sonst nicht passt. Lazy-Varianten (*?, +?, ??, {n,m}?) matchen so wenig wie moeglich und erweitern nur bei Bedarf. Bei <.*> bekommst du den groessten Match, bei <.*?> den kleinsten.i-Flag: /foo/i matcht foo, FOO, Foo. In PCRE und vielen anderen Engines geht das gleiche per Modifier (?i) direkt im Pattern: (?i)foo. Wer nur Teile case-insensitive haben will, nutzt (?i:foo)bar in PCRE.. per Default kein \n matcht. Aktiviere den DOTALL-Modus mit dem s-Flag (/pattern/s) oder dem inline-Modifier (?s). Alternativ matche explizit jeden Zeichensatz: [\s\S]* oder [\d\D]*.\. matcht den Punkt literal, \? das Fragezeichen, \( die runde Klammer. In Code-Strings musst du den Backslash zusaetzlich escapen: in JavaScript "\\.", in PHP-Strings "\\." oder besser den Single-Quote-String '\.'.^(a+)+$ auf aaaaaaaaaaaaaaaab braucht Sekunden bis Minuten — und das ist nur 17 Zeichen. Vermeidung: Pattern entschachteln, possessive oder atomic groups, oder eine RE2-basierte Engine wie Go/regexp oder Rust/regex.(?J) existieren in JS nicht.