Kostenloser Regex-Tester — Muster online testen und debuggen
Testen Sie reguläre Ausdrücke online sofort gegen beliebigen Text. Live-Treffer-Hervorhebung, Erfassungsgruppen, Ersetzungs-Vorschau, Split und Muster-Erklärer. JavaScript-Regex, 100 % Datenschutz, kostenlos, ohne Anmeldung.
Unser Team validiert die Regex-Ausgabe gegen die ECMA-262-Spezifikation, das RegExp-Verhalten in Node.js sowie Cross-Engine-Paritätstests in V8 / JavaScriptCore / SpiderMonkey. Das ReDoS-Budget ist gegen die dokumentierten Worst-Case-Muster aus den Regex-DoS-Korpora von Snort und OWASP kalibriert.
Was ist ein Regex-Tester?
Ein Regex-Tester (Tester für reguläre Ausdrücke) ist ein Werkzeug, mit dem Sie ein Regex-Muster schreiben, einen Probetext einfügen und genau sehen, was das Muster trifft — mit Erfassungsgruppen, Ersetzungs-Vorschau und Flag-Aufschlüsselung — ohne Code neu zu kompilieren oder ein Skript auszuführen. Für Entwickler verkürzt das die Schleife von Minuten auf Millisekunden: Muster anpassen, beobachten, wie die Markierungen wandern, und den regulären Ausdruck mit Vertrauen ausliefern.
Ein regulärer Ausdruck ist eine kompakte Sprache zur Beschreibung von Textmustern. \d+ trifft eine oder mehrere Ziffern. [A-Za-z_]\w* trifft einen typischen Bezeichner. (?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2}) trifft ein ISO-Datum und benennt jeden Bestandteil. Reguläre Ausdrücke sind das Rückgrat von Suchen und Ersetzen in jedem Code-Editor, von Validierung in jedem Formular, von Log-Parsing in jedem Observability-Stack sowie von grep, sed und awk — den Unix-Werkzeugen, auf denen das halbe Internet läuft. Sie sind aber auch berüchtigt schwer korrekt zu schreiben: ein Off-by-one-Quantor oder ein fehlender Escape kann den falschen Teilstring treffen, einen Treffer ganz verfehlen oder — im schlimmsten Fall — katastrophales Backtracking auslösen, das einen CPU-Kern als Geisel nimmt. Ein guter Regex-Tester fängt jeden dieser Fehlermodi ab, bevor sie die Produktion erreichen.
Dieser Tester führt die native ECMA-262-RegExp-Engine aus, die in jedem modernen Browser ausgeliefert wird — dieselbe Engine, die Sie aus JavaScript, TypeScript, Node.js, Deno oder Bun aufrufen. Das heißt: Erfassungsgruppen (nummeriert und benannt mit (?<name>...)), Lookahead- und Lookbehind-Behauptungen ((?=...), (?!...), (?<=...), (?<!...)), die sieben kanonischen Flags (g, i, m, s, u, y, d), Unicode-Eigenschafts-Escapes (\p{Letter}, \p{Script=Han}) unter /u und Zeichen-Escapes im \d-Stil. Muster, die Sie hier validieren, fügen sich direkt in Ihre Codebasis ein und funktionieren unverändert. Wenn Sie von PCRE, Python oder Java portieren, schlüsselt der Erklärer jeden Token auf, sodass Sie Syntax erkennen, die sich nicht übersetzen lässt (atomare Gruppen, possessive Quantoren, Inline-Modifikatoren).
Was der Tester über rohe Treffer hinaus zeigt: Das Panel Treffer & Erfassungsgruppen listet jeden Treffer mit seinen [start, end)-Offsets und dem Wert jeder Erfassungsgruppe — dieselben Informationen, die Sie von String.prototype.matchAll mit dem /d-Flag bekommen würden, aber auf das visuelle Überfliegen ausgelegt. Der Ersetzen-Tab zeigt eine Live-Substitutions-Vorschau und unterstützt das vollständige Template-Alphabet $1 / $& / $` / $' / $$ / $<name> — exakt das, was JavaScripts String.replace akzeptiert. Der Split-Tab wendet String.split mit dem regulären Ausdruck an und zeigt jeden Teil. Der Erklären-Tab tokenisiert das Muster und annotiert jedes Stück in einfachem Deutsch, nützlich für Code-Reviews, Lehre und Portieren zwischen Dialekten.
Zum Datenschutz: Jeder Vorgang ist lokal. Ihr Muster und Ihr Testtext verlassen die Seite niemals — sie werden nicht protokolliert, nicht an einen Analyse-Dienst gesendet, nicht auf der Festplatte gespeichert. Nur Ihre UI-Voreinstellungen (aktiver Tab und welche Flags Sie üblicherweise aktiviert haben) werden im localStorage gespeichert. Damit ist dieses Tool sicher für geschwärzte Log-Auszüge, firmeneigene Muster, interne Konfiguration und Muster, die Hinweise auf Ihr Datenschema enthalten. Im Vergleich zu serverseitigen Testern wie regex101 ist die Datenschutz- und Latenzbilanz strikt besser; der Kompromiss ist die Unterstützung eines einzigen Dialekts (nur JavaScript).
Wenn Sie neu in Regex sind, liefert das Dropdown Häufige Muster kampferprobte Starter mit: E-Mail-Adresse, URL, IPv4, UUID, Hex-Farbe, ISO-Datum, US-Telefonnummer sowie ein Muster zum Entfernen nachgestellter Leerzeichen. Laden Sie eins, beobachten Sie die Treffer im mitgelieferten Probetext und mutieren Sie das Muster dann zeichenweise, um zu spüren, wie die Engine reagiert. Kombinieren Sie das mit dem Werkzeug Text-Diff, wenn Sie Vorher/Nachher einer regex-gesteuerten Bereinigung vergleichen wollen, mit dem JSON-Formatierer, wenn Ihre Eingabe oder erwartete Ausgabe JSON ist, oder mit dem URL-Kodierer, wenn die Strings, die Sie treffen wollen, URL-kodiert sind.
// The pattern you build in this tester drops straight into JavaScript.
// Example: extract every ISO date from a string with named groups.
const pattern = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g;
const text = 'shipped 2026-05-21, scheduled 2026-06-30';
for (const m of text.matchAll(pattern)) {
console.log(m.groups.year, m.groups.month, m.groups.day);
// → 2026 05 21
// → 2026 06 30
}
// Same regex, used in a replace with $<name> templates:
text.replace(pattern, '$<day>/$<month>/$<year>');
// → 'shipped 21/05/2026, scheduled 30/06/2026'
// With the /d flag, every match carries [start, end] indices
// per capture group — the Matches panel uses this to paint offsets.
const p2 = /(?<year>\d{4})-(?<month>\d{2})/gd;
const m = [...text.matchAll(p2)][0];
m.indices.groups.year; // [8, 12] Hauptfunktionen
Live-Treffer-Hervorhebung
Jeder Treffer in Ihrem Testtext leuchtet sofort auf, sobald Ihr Muster parst. Alternierende Farben machen benachbarte Treffer visuell leicht zählbar, und das Zähler-Badge über dem Ergebnis nennt Ihnen die genaue Gesamtzahl — kein Start-Button, keine Debounce-Verzögerung über 200 ms.
Seitenpanel für Erfassungsgruppen
Das Panel Treffer & Erfassungsgruppen rechts listet jeden Treffer als Karte mit seinen [start, end)-Offsets, dem vollständigen Treffer-Text und jeder positionalen sowie benannten Erfassungsgruppe darin. Benannte Gruppen beschriften sich selbst als $<name>, sodass Sie die Daten genauso lesen, wie Sie sie im Code konsumieren werden.
Live-Ersetzungs-Vorschau mit $1 / $& / $<name>
Wechseln Sie in den Ersetzen-Tab, um Ihre Substitution in Echtzeit angewendet zu sehen. Das vollständige ECMAScript-Ersetzungs-Alphabet funktioniert: $1..$N für positionale, $<name> für benannte, $& für den gesamten Treffer, $` und $' für Präfix/Suffix, $$ für ein literales Dollarzeichen. Eingabe- und Ausgabe-Panels Seite an Seite mit Ein-Klick-Kopie.
Split mit Regex-Grenzen
Der Split-Tab ruft String.prototype.split mit Ihrem regulären Ausdruck auf und zeigt jeden Teil als nummerierte Liste. Leere Teile werden mit einem ⏎-Glyph gerendert, sodass Sie sehen, wie die Engine angrenzende Trennzeichen behandelt hat — nützlich beim Debuggen der Bereinigung CSV-ähnlicher Eingaben.
Muster-Erklärer (Token für Token)
Der Erklären-Tab tokenisiert Ihr Muster in Chips, die nach Klasse (Escape / Quantor / Zeichenklasse / Gruppe / Anker / Alternation) eingefärbt sind, und annotiert jeden Chip mit einer einzeiligen Beschreibung. Lesen Sie Ihren eigenen regulären Ausdruck sich selbst vor dem Ausliefern noch einmal vor; verwenden Sie ihn für Code-Reviews oder die Lehre.
ReDoS-sicher (Wall-Clock-Timeout)
Jeder Treffer-Aufruf ist in ein 250-Millisekunden-Budget eingepackt. Klassische Formen katastrophalen Backtrackings wie (a+)+, (a|aa)+b und tief verschachtelte Quantoren brechen sauber mit der Warnung Muster zeitüberschritten ab — die Seite bleibt reaktionsfähig, statt den Tab einzufrieren. Erkennung ohne serverseitige Sandbox.
Bibliothek häufiger Muster
Kampferprobte Starter für die acht Muster, zu denen Entwickler am häufigsten greifen: E-Mail, URL, IPv4, UUID v4, Hex-Farbe, ISO-Datum, US-Telefonnummer und das Entfernen nachgestellter Leerzeichen. Jedes lädt mit einer passenden Probe, sodass Sie den regulären Ausdruck arbeiten sehen, bevor Sie ihn anpassen.
Permalink-Teilen (kein Upload)
Link kopieren kodiert Muster + Flags + Probetext in den URL-Hash (#p=…&f=gim&t=…). Browser übertragen URL-Fragmente niemals in Requests, sodass ein geteilter Link Ihren Zustand auf dem Rechner des Empfängers reproduziert, ohne go-tools.org-Server zu berühren. In sich geschlossen, audit-freundlich.
100 % Datenschutz, ausschließlich im Browser
Ihr regulärer Ausdruck und Ihr Testtext verlassen Ihr Gerät niemals. Keine Netzwerk-Requests, kein Logging, keine Analyse dessen, was Sie tippen. Prüfen Sie es in DevTools → Netzwerk: null Requests, wenn Sie tippen. Sicher für firmeneigene Muster, geschwärzte Logs und alles, was Sie nicht in regex101 einfügen würden.
Ausgearbeitete Beispiele
Jede E-Mail-Adresse aus einem Absatz extrahieren
[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,} /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g Fügen Sie das Muster mit aktiviertem /g-Flag ein, kippen Sie einen Absatz in den Testtext, und jede E-Mail-Adresse leuchtet in der hervorgehobenen Ansicht auf. Das Panel Treffer & Erfassungsgruppen rechts listet jede Adresse mit ihren [start, end)-Offsets — nützlich, wenn Sie denselben regulären Ausdruck an grep, sed oder einen Code-Editor weiterreichen.
Datumsbestandteile mit benannten Gruppen erfassen
(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2}) /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g Benannte ECMA-262-Gruppen erscheinen im rechten Panel als $<year>, $<month>, $<day>. Wechseln Sie in den Ersetzen-Tab und probieren Sie $<day>/$<month>/$<year>, um ISO-Datumsangaben in einem Durchgang ins DMY-Format umzubauen — derselbe Trick funktioniert in jedem modernen JS-replace-Aufruf.
Suchen/Ersetzen mit $1-Rückverweisen
(\w+) (\w+)
Ersetzung: $2, $1 → Jack Doe → Doe, Jack
Zwei unbenannte Erfassungsgruppen, Ersetzungs-Template $2, $1, und der Ersetzen-Tab liefert Ihnen eine Live-Vorschau. $&, $`, $', $$ und $<name> werden alle unterstützt — exakt das Substitutions-Alphabet aus der ECMAScript-Spezifikation, sodass das, was Sie herauskopieren, unverändert in jeder JS-Engine läuft.
Nachgestellte Leerzeichen Zeile für Zeile entfernen
[ \t]+$
/[ \t]+$/gm
Kombinieren Sie die Flags /g (global) und /m (multiline), sodass $ an jedem Zeilenende verankert wird, nicht nur am Ende der Eingabe. Der Ersetzen-Tab mit einer leeren Ersetzungs-Vorschau zeigt einen sauberen Diff: nachgestellte Tabs und Leerzeichen verschwinden, der Fließtext bleibt stehen. Derselbe reguläre Ausdruck mit deaktiviertem /s (dotAll) hält den Punkt davon ab, Zeilenumbrüche zu überschreiten.
Katastrophales Backtracking erkennen und überleben
(a+)+b
Testtext: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac
Die verschachtelten +-Quantoren bilden ein klassisches ReDoS-Muster. In einem naiven Tester hängt das den Tab auf. Hier feuert der Wall-Clock-Schutz nach 250 ms, das Banner Muster zeitüberschritten erscheint, und die Seite bleibt reaktionsfähig. Verankern Sie das Muster, wechseln Sie zu einer überschneidungsfreien Alternation oder verwenden Sie atomic-ähnliche Idiome — und testen Sie erneut.
Eine CSV-ähnliche Zeile nach gemischten Trennzeichen aufteilen
[,;|]\s*
alpha, beta; gamma | delta → ["alpha", "beta", "gamma", "delta"]
Wechseln Sie in den Split-Tab. Jedes Komma, Semikolon oder jeder Pipe-Strich (gefolgt von optionalem Whitespace) wird zu einer Trenngrenze. Nützlich zum Bereinigen kopierter Tag-Listen, zum Normalisieren von Benutzereingaben oder zum Vorbereiten von Log-Feldern vor einem echten CSV-Parser — siehe CSV zu JSON, wenn die Daten tatsächlich RFC-4180-konform sind.
So verwenden Sie den Regex-Tester
- 1
Tippen Sie Ihr Muster zwischen die Schrägstriche
Kippen Sie einen beliebigen ECMA-262-regulären Ausdruck in das /…/-Feld. Schlechte Muster leuchten rot mit einer Parser-Meldung; gültige Muster gehen zum Live-Matching über.
- 2
Schalten Sie die benötigten Flags um
g (global), i (case-insensitive), m (multiline), s (dotAll), u (unicode), y (sticky), d (indices). Jeder Chip leuchtet, wenn er aktiv ist; die Anzeige rechts neben dem Muster zeigt das kanonische Literal.
- 3
Fügen Sie Ihren Testtext ein
Treffer werden während des Tippens in alternierenden Farben hervorgehoben. Das Panel Treffer & Erfassungsgruppen rechts listet jeden Treffer mit [start, end)-Offsets und dem Wert jeder Erfassungsgruppe (benannte Gruppen als $<name> beschriftet).
- 4
Wechseln Sie Tabs für Ersetzen, Split oder Erklären
Ersetzen zeigt ein Substitutions-Template neben der Eingabe vor. Split zerlegt an jeder Treffer-Grenze. Erklären schlüsselt das Muster Token für Token mit einer Beschreibung pro Element in einfachem Deutsch auf.
- 5
Literal kopieren oder Permalink teilen
/pattern/flags kopieren legt das kanonische Regex-Literal in Ihrer Zwischenablage ab — direkt einsetzbar in JavaScript / TypeScript / Node. Link kopieren kodiert den vollständigen Zustand in einen URL-Hash (kein Upload), sodass ein Kollege ihn lokal reproduzieren kann.
Häufige Regex-Fehler
Das /g-Flag vergessen und nur einen Treffer bekommen
Ohne /g (oder /y) stoppt die Engine nach dem ersten Treffer. Die Methoden match, matchAll, replace und split verhalten sich rund um das Global-Flag jeweils unterschiedlich. Schalten Sie /g ein und lassen Sie erneut laufen; der Zähler über den Ergebnissen springt von 1 auf N.
Muster: /\d+/ → '1 22 333' ergibt nur ['1']
Muster: /\d+/g → '1 22 333' ergibt ['1', '22', '333']
Gieriger Quantor hat zu viel konsumiert
.+ konsumiert so viel wie möglich, sodass <.+> gegen <a> and <b> <a> and <b> erfasst, nicht <a>. Verwenden Sie faule Quantoren (.+?), strengere Zeichenklassen ([^>]+) oder verankern Sie mit Lookarounds.
Muster: /<.+>/ → trifft '<a> and <b>'
Muster: /<[^>]+>/ → trifft '<a>' und '<b>' getrennt
Katastrophales Backtracking durch verschachtelte Quantoren
(a+)+b gegen eine lange, fehlschlagende Zeichenkette explodiert exponentiell. Das Banner Muster zeitüberschritten feuert nach 250 ms; schreiben Sie um, um die Verschachtelung zu entfernen: a+b erledigt dieselbe Aufgabe in linearer Zeit. Die Simulation einer atomaren Gruppe (?=(a+))\1b ist eine weitere Option.
Muster: /(a+)+b/ auf 'aaaaaaaaaaaaaaaaaaaaac' → Timeout
Muster: /a+b/ auf derselben Eingabe → sofortiges 'kein Treffer'
Die Anker $ und ^ verhalten sich nicht wie Pythons \A und \Z
In JavaScript bedeuten ^ und $ NUR dann Zeilen-Anfang / Zeilen-Ende, wenn /m aktiv ist; sonst bedeuten sie String-Anfang / String-Ende. Pythons \A und \Z (die immer String-Grenzen bedeuten) existieren in JS nicht. Schalten Sie /m bei Bedarf um.
Muster: /^Error/ auf einem mehrzeiligen Log ohne /m → trifft nur die erste Zeile
Muster: /^Error/m auf derselben Eingabe → trifft jede Zeile, die mit Error beginnt
$1 in einem String verwendet, aber replace mit einer Funktion aufgerufen
text.replace(re, '$1') expandiert den Rückverweis. text.replace(re, () => '$1') übergibt einen literalen String '$1', weil Funktionen die Template-Tokens nicht sehen. Innerhalb der Funktion treffen Erfassungsgruppen als positionale Argumente ein.
text.replace(/(\w+)/, m => '$1') → liefert literales '$1'
text.replace(/(\w+)/, (_, g1) => g1.toUpperCase()) → nutzt die Erfassung
Unicode-Zeichen werden mit \w oder . nicht getroffen
Das Standard-\w ist [A-Za-z0-9_]. Um jeden Buchstaben in jeder Schrift zu treffen, aktivieren Sie /u und wechseln Sie zu \p{Letter} (\p{L}). Der Punkt bleibt außerdem standardmäßig an Zeilenumbrüchen stehen — verwenden Sie /s (dotAll), wenn Sie ein echtes Beliebiges-Zeichen wollen.
Muster: /\w+/ trifft 'hello', aber nicht 'héllo' oder '你好'
Muster: /\p{Letter}+/u trifft alle drei Ein PCRE-Muster eingefügt; einen SyntaxError bekommen
JavaScript unterstützt keine atomaren Gruppen (?>...), possessive Quantoren a++, Inline-Modifikatoren (?i), Konditionale (?(1)yes|no) oder \A / \Z. Der Parser-Fehler nennt das anstößige Konstrukt — schreiben Sie es in das JS-unterstützte Äquivalent um (Lookaround-Simulation, separates Flag-Umschalten, Alternation).
Muster: (?i)foo → SyntaxError: ungültige Gruppe
Muster: foo mit aktiviertem /i-Flag → gleicher Effekt
Wer dieses Tool nutzt
- Formular-Eingaben vor dem Ausliefern validieren
- Bestätigen Sie, dass Ihr E-Mail- / Telefon- / PLZ- / Benutzername-Regex das trifft, was Sie erwarten — und ablehnt, was Sie nicht erwarten — über Randfälle hinweg (Unicode-Namen, Plus-Aliasing, internationale Formate), bevor die Validierung Produktion erreicht und echte Nutzer abweist.
- Daten aus Logs und Konfigurationen extrahieren
- Bauen Sie ein Muster, das Request-IDs, Statuscodes, Latenzen oder Stacktrace-Zeilen aus einem beliebigen Log-Auszug zieht. Benannte Gruppen machen die Daten selbstdokumentierend; das Treffer-Panel zeigt Offsets, sodass Sie denselben regulären Ausdruck anschließend in
rg --replaceodergrep -oEweiterreichen können. - Suchen/Ersetzen über eine ganze Codebasis
- Entwerfen Sie ein Refactoring-Muster (z. B.
(\w+)\.apply\(null,\s*\[(.*?)\]\)→$1($2)) hier, schauen Sie die Substitution gegen repräsentative Schnipsel vor, und fügen Sie den validierten regulären Ausdruck dann mit Vertrauen in das projektweite Suchen/Ersetzen Ihres Editors ein. - Ein online gefundenes Muster auf Plausibilität prüfen
- Einen regulären Ausdruck aus StackOverflow oder einem Blog kopiert? Werfen Sie ihn in den Erklären-Tab — jeder Token wird in einfachem Deutsch annotiert. Fängt subtile Probleme ab (
.+?, wo Sie.+wollten, fehlende^/$-Anker, versehentlich gierige Quantoren), bevor der reguläre Ausdruck in Ihrem Code landet. - Regex einem Teamkollegen beibringen
- Öffnen Sie den Erklären-Tab auf einem funktionierenden Muster und gehen Sie ihn Token für Token durch. Die Farb-Kodierung (Escape / Quantor / Zeichenklasse / Gruppe / Anker / Alternation) lässt die Lernende die strukturelle Form des regulären Ausdrucks sehen, nicht nur die Zeichen.
- Ein Muster zwischen Sprachen portieren
- Haben Sie einen Python- oder PCRE-Regex, den Sie in JavaScript brauchen? Fügen Sie ihn hier ein. Wenn er parst, zeigt der Erklärer die JS-äquivalente Semantik; tut er es nicht, nennt der Parser-Fehler das anstößige Konstrukt (atomare Gruppen, possessive Quantoren, Inline
(?i)) — Sie wissen also genau, was umzuschreiben ist. - Einen langsamen Produktions-Regex debuggen
- Wenn ein Server-Regex unter Verdacht auf katastrophales Backtracking steht, fügen Sie ihn mit einer Probe der Eingabe in diesen Tester ein. Der 250-ms-Wall-Clock-Schutz schlägt bei pathologischen Fällen an und liefert Ihnen eine sofortige Diagnose, bevor Sie zu Profiler-Werkzeugen greifen — und der Erklärer zeigt auf die Ursache aus verschachtelten Quantoren.
Hinweise zu Engine und Algorithmus
- ECMA-262-RegExp-Engine (nativ im Browser)
- Verwendet
new RegExp(pattern, flags)und die Engine, die mit V8 / JavaScriptCore / SpiderMonkey ausgeliefert wird — dieselbe Regex-Semantik, die Sie in JavaScript überall erhalten. Muster, die hier validieren, laufen unverändert in Node.js, Deno, Bun und jedem modernen Browser. - Treffer-Iteration über String.matchAll
- Die globale Iteration verwendet
text.matchAll(regex)statt einer manuellen lastIndex-Schleife, sodass jeder Treffer seine Erfassungsgruppen, benannten Gruppen und (mit /d) [start, end]-Indizes mitführt. Treffer mit Nullbreite werden mit dem üblichen +1-lastIndex-Vorrücken behandelt, um Endlosschleifen zu vermeiden. - Wall-Clock-Timeout als ReDoS-Schutz
- Ein 250-Millisekunden-Budget umfasst jeden Treffer-, Ersetzen- und Split-Aufruf. Die Engine kann bei einem einzelnen Treffer-Versuch intern weiter backtracken, aber die äußere Iteration arbeitet mit dem Budget zusammen — pathologische Muster brechen mit
timedOut: trueab, und die UI zeigt eine Warnung, statt den Tab einzufrieren. - Eigene Implementierung des Ersetzungs-Templates
- Der Ersetzen-Tab parst $1..$N, $&, $
, $', $$ und $<name> selbst, statt anString.replace` zu delegieren — damit verhält sich die Vorschau über Engines hinweg identisch (ältere Safari, älteres Node), wo Templates mit benannten Gruppen Randfälle haben. Die Ausgabe entspricht exakt dem, was aktuelle JavaScript-Engines produzieren. - Muster-Tokenizer für den Erklärer
- Der Erklären-Tab führt einen handgeschriebenen Tokenizer aus, der jedes Muster-Fragment klassifiziert (Escape / Metazeichen / Quantor / Zeichenklasse / Gruppe-auf / Gruppe-zu / Anker / Alternation). Unbekannte Konstrukte fallen mit einer generischen Notiz auf
literalzurück, sodass der Erklärer nie stillschweigend Inhalt verliert. - Permalinks über URL-Hash (niemals übertragen)
- Der geteilte Zustand wird im location.hash-Fragment kodiert (
#p=…&f=…&t=…&tab=…). Browser übertragen das Fragment niemals in HTTP-Requests, sodass go-tools.org-Server beim Öffnen eines Permalinks null Daten erhalten. Die Hydratation findet vollständig auf dem Gerät des Empfängers statt.
Best Practices für Regex
- Muster verankern, wenn Sie es meinen
^pattern$trifft eine exakte Zeichenkette;patterntrifft überall. Die falsche Wahl ist der häufigste Bug in der Formular-Validierung: ein fehlendes^lässt ein vorangestelltesattacker.com/an einer Domain-Prüfung vorbei; ein fehlendes$lässt nachgestellten Müll durch. Verwenden Sie den Treffer-Tab gegen absichtlich kaputte Proben, um zu bestätigen, was abgelehnt wird.- Nicht-erfassende Gruppen für reine Struktur bevorzugen
(?:foo|bar)+und(foo|bar)+sind funktional identisch, aber die erste allokiert keine Erfassungsgruppe. Greifen Sie zu(?:…), wann immer die Gruppe nur wegen eines Quantors oder einer Alternation existiert — das hält Ihre nummerierten $1..$N stabil und spart der Engine eine winzige Menge Arbeit.- Verwenden Sie das /u-Flag für alles jenseits von ASCII
- Ohne /u behandeln der Punkt und
\wSurrogat-Paar-Zeichen (Emoji, Non-BMP-Codepunkte) als zwei UTF-16-Einheiten. Mit /u sind sie jeweils ein Codepunkt — das, was Ihre Nutzer wahrnehmen. /u aktiviert außerdem\p{Letter}und andere Eigenschafts-Escapes. Setzen Sie /u für neue Muster standardmäßig, sofern Sie keinen konkreten Grund dagegen haben. - Benennen Sie Ihre Erfassungsgruppen
(?<year>\d{4})-(?<month>\d{2})ist selbstdokumentierend. Sechs Monate später, wenn Sie den regulären Ausdruck wieder lesen, istm.groups.yearoffensichtlich das Jahr —m[1]nicht. Ersetzungs-Templates mit $<name> überstehen außerdem das Umordnen von Gruppen: Positionale Templates brechen in dem Moment, in dem jemand eine weitere Gruppe hinzufügt.- Testen Sie Fehlerfälle, nicht nur Erfolge
- Ein Regex-Tester ist für die Misserfolge da. Bestätigen Sie, was Ihr Muster trifft, und mutieren Sie den Testtext dann absichtlich, um zu sehen, was es nicht trifft — vorangestellter Whitespace, nachgestellter Whitespace, fehlende Teile, zusätzliche Teile, falsche Groß-/Kleinschreibung, gemischte Schriften. Muster, die gültige Eingaben durchlassen, aber Müll akzeptieren, sind die Bugs, die die Produktion zuerst aufdeckt.
Häufig gestellte Fragen
Werden mein regulärer Ausdruck oder mein Testtext an Ihren Server gesendet?
Welchen Regex-Dialekt verwendet dieser Tester — PCRE, Python, Java, JavaScript?
new RegExp(pattern, flags) in jedem Browser, in Node.js, Deno oder Bun bekommen. Das heißt, die unterstützten Funktionen sind: Erfassungsgruppen (nummeriert und benannt mit (?<name>...)), Lookaheads (?=...) und (?!...), Lookbehinds (?<=...) und (?<!...), die sieben Flags g/i/m/s/u/y/d, Unicode-Eigenschafts-Escapes (\p{Letter}) unter /u sowie Rückverweise \1..\9. PCRE-spezifische Funktionen wie atomare Gruppen (?>...), possessive Quantoren a++, Konditionale (?(1)yes|no) und Inline-Modifikatoren (?i) werfen einen Syntax-Fehler. Pythons re.VERBOSE wird hier nicht unterstützt. Für Python-/Java-/Go-Regex portieren Sie das Muster zurück in dessen native Engine — die meisten einfachen Muster lassen sich unverändert übertragen, und der Erklärer hier ist dialektneutral. Was bewirken die einzelnen Flags g, i, m, s, u, y, d?
.indices und .indices.groups mit [start, end]-Paaren für jede Erfassung; dieser Tester nutzt /d intern, um die Gruppen-Grenzen zu zeichnen. Schalten Sie sie über die Chips oberhalb des Testtexts um; das kanonische /pattern/flags-Literal erscheint in der Anzeige. Wie schreibe ich Erfassungsgruppen, und wie verweise ich auf sie zurück?
(\d{4})-(\d{2})-(\d{2}) ergibt drei positionale Gruppen, im Ersetzen erreichbar als $1, $2, $3 oder im Treffer-Panel als m.groups[0..2]. Verwenden Sie (?<name>...) für benannte Gruppen: (?<year>\d{4})-(?<month>\d{2}) erlaubt es, im Ersetzungs-Template $<year>/$<month> zu schreiben. Verwenden Sie (?:...) für eine nicht-erfassende Gruppe, wenn Sie die Gruppierung nur für einen Quantor brauchen ((?:foo|bar)+) — sie erzeugt keinen Rückverweis, was Ihre nummerierten $1..$N stabil hält. Innerhalb desselben Musters verweisen Sie mit \1, \2 usw. auf eine frühere Erfassung — praktisch, um Wortverdopplungen wie \b(\w+)\s+\1\b zu finden. Wie funktionieren Lookahead und Lookbehind, und wofür sind sie gut?
(?=foo) (positiver Lookahead) gelingt, wenn foo auf die aktuelle Position folgt; (?!foo) (negativer Lookahead) gelingt, wenn foo NICHT folgt. (?<=foo) und (?<!foo) sind die Lookbehind-Gegenstücke. Praktische Anwendungen: einen Teilstring ohne seine Umgebung extrahieren ((?<=\$)\d+ trifft die Ziffern nach einem Dollarzeichen, aber $ ist nicht Teil des Treffers), Validierung mit mehreren Bedingungen in einem Muster ((?=.*[A-Z])(?=.*\d).{8,} verlangt mindestens einen Großbuchstaben, eine Ziffer und 8 Zeichen) und das Verbieten von Vorkommen (^(?!.*\bpassword\b) lehnt jede Zeile mit dem Wort password ab). Modernes ECMA-262 unterstützt Lookbehinds variabler Länge, sodass (?<=^prefix-?) funktioniert. Warum hängt mein regulärer Ausdruck den Browser auf, und was ist katastrophales Backtracking?
(a+)+, (a|aa)+, (\w*)* oder (?:a|a?)+. Bei einer Eingabe, bei der der Treffer am letzten Zeichen scheitern kann, probiert die Engine eine exponentielle Anzahl von Gruppen-Aufteilungen aus, bevor sie aufgibt. Für aaaaaaaaaaaaaaaaaaaaab mit dem Muster (a+)+b sind das 2^21 ≈ 2 Millionen Backtracks bis zur Antwort. Dieser Tester verpackt jeden Treffer-Aufruf in ein 250-ms-Wall-Clock-Budget — wird das Budget überschritten, stoppt die Iteration, und Sie sehen die Warnung Muster zeitüberschritten. Lösungen: das Muster an seine Grenzen verankern (^...$), überschneidungsfreie Alternativen bevorzugen ((a|b) statt (a|aa)), verschachtelte Quantoren entrollen (a+ statt (a+)+) oder das Muster mit possessive-ähnlichen Idiomen umschreiben ((?=(a+))\1 simuliert in JS a++). Wie unterscheidet sich dieser Regex-Tester von regex101.com?
Wie escape ich Sonderzeichen wie . | ( ) [ ] { } * + ? ^ $ \?
\., \|, \(, \), \[, \], \{, \}, \*, \+, \?, \^, \$, \\. Der Vorwärts-Schrägstrich / muss in einem als String übergebenen Muster nicht escaped werden (nur in JS-Regex-Literalen zwischen den Schrägstrichen). Innerhalb einer Zeichenklasse [...] verlieren die meisten Metazeichen ihre Sonderbedeutung, sodass [.], [*], [+] jeweils ein literales Zeichen treffen — die einzigen Metazeichen, die ihre Sonderbedeutung behalten, sind ], \, ^ (nur am Anfang zur Negation) und - (Bereich, wenn zwischen zwei Zeichen). Im Zweifel fügen Sie den literalen Text ins Muster ein und starten den Erklärer: Jede Escape-Sequenz erhält im Aufschlüsselungs-Panel eine einzeilige Beschreibung. Kann ich einen regulären Ausdruck per Link mit einem Kollegen teilen?
#p=...&f=gim&t=...&tab=match). Wer den Link öffnet, hydratisiert die Seite mit demselben Zustand — lokal auf seinem Rechner. Da die Daten im Hash-Fragment liegen, werden sie niemals an den go-tools.org-Server gesendet (Browser übertragen Fragmente nicht in Requests) und tauchen nicht in unseren Access-Logs auf. Die Linklänge wächst mit der Textgröße; für Proben >2 KB kopieren Sie das Muster über /pattern/flags kopieren und fügen den Text separat ein. Für kollaborative Regex-Reviews ohne den eigentlichen Text zu teilen, geben Sie nur Muster und Flags weiter — der Empfänger fügt seinen eigenen Korpus ein und erhält dieselben Treffer. Unterstützt der Tester Unicode, Emoji und nicht-lateinische Schriften?
\p{Letter} trifft jeden Buchstaben in jeder Schrift, \p{Script=Han} trifft chinesische Ideogramme, \p{Emoji} trifft Emoji, \p{Number} trifft jede Ziffer/jedes Zahlzeichen. Ohne /u werden Surrogat-Paar-Emoji wie 👨💻 als zwei UTF-16-Codeunits gesehen, und Muster wie ^.$ treffen sie nicht; mit /u behandelt der Punkt jeden Grapheme-Codepunkt als ein Zeichen. Für RTL-Schriften (Arabisch, Hebräisch) funktionieren Muster ohne Sonderbehandlung — die Richtung ist eine Render-Zeit-Angelegenheit, kein Anliegen der Regex-Engine. CJK-Inhalt wird genauso getroffen wie lateinischer. Was ist der Unterschied zwischen .match, .matchAll, .replace und .split mit einem regulären Ausdruck?
Warum funktioniert mein Python- oder Java-Regex hier nicht?
(?i) und (?x) sind in JS nicht gültig — verwenden Sie stattdessen die Flag-Chips oben. (2) Pythons \A und \Z sind in JS ^ und $ (mit /m für Zeilenanker). (3) Java-/Python-Konditionale (?(name)yes|no) werden in JS nicht unterstützt — schreiben Sie sie mit einer Alternation um. (4) Possessive Quantoren a++ und atomare Gruppen (?>...) gibt es in JS nicht — simulieren Sie sie mit (?=(a+))\1. (5) Python (?P<name>...) ist in JS (?<name>...). (6) \h für horizontalen Whitespace und \v für vertikalen gibt es in JS nicht — verwenden Sie [ \t] und [\n\r]. Für eine portable Migration schlüsselt der Erklärer auf, was jeder Token tut, sodass Sie die nicht unterstützte Syntax durch ein Äquivalent ersetzen können. Gibt es eine maximale Textgröße oder Trefferanzahl?
grep -oE oder rg (ripgrep) — sie streamen und stoßen nicht an eine UI-Rendering-Grenze. Für einmalige Scans gewaltiger Texte fügen Sie einen repräsentativen Auszug in diesen Tester ein, um das Muster zu validieren, und führen das validierte Muster dann in Ihrer Shell gegen die vollständige Datei aus. Verwandte Werkzeuge
Alle Werkzeuge anzeigen →Case-Konverter — UPPERCASE, lowercase, camelCase & mehr
Textverarbeitung
Konvertieren Sie Text sofort zwischen UPPERCASE, lowercase, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE und 6 weiteren Formaten. Kostenlos, nur im Browser, ohne Anmeldung.
Lorem-Ipsum-Generator — Blindtext erstellen
Textverarbeitung
Lorem-Ipsum-Blindtext sofort generieren — nach Absatz, Satz, Wort, Byte oder Liste. Kopieren oder als Text, HTML, Markdown oder JSON herunterladen. 100 % kostenlos, privat, im Browser. Ohne Anmeldung.
Doppelte Zeilen aus Text entfernen
Textverarbeitung
Doppelte Zeilen aus Text online entfernen — kostenlos, sofort, 100 % im Browser. Groß-/Kleinschreibung oder Leerzeichen ignorieren, erstes oder letztes Vorkommen behalten, entfernte Duplikate sehen. Keine Anmeldung.
URL-Slug-Generator — Text in Slugs umwandeln
Textverarbeitung
Wandeln Sie jeden Titel sofort in einen sauberen, SEO-freundlichen URL-Slug um. Akzente und Kyrillisch transliterieren oder Unicode-Buchstaben behalten. 100 % privat, im Browser.
Textzeilen alphabetisch & natürlich sortieren
Textverarbeitung
Textzeilen alphabetisch, numerisch (natürliche Reihenfolge) oder nach Länge sortieren — auf- oder absteigend. Kostenlos, 100 % im Browser. Auch entduplizieren, umkehren und Listen bereinigen. Keine Anmeldung.
Text vergleichen & Diff
Textverarbeitung
Vergleichen Sie zwei Texte sofort im Browser. Nebeneinander-Ansicht mit Wort-Markierung, Unified-Diff-Export, Ignorieren von Groß/Klein, Leerzeichen, Leerzeilen. 100 % im Browser — kein Upload.