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.
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. `(?
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 `(? 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 / $& / $` / $' / $$ / $ 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 $
Live-Ersetzungs-Vorschau mit $1 / $& / $
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, $
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 $
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 $
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 $
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 ` and ` ` and ` erfasst, nicht ``. 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 --replace` oder `grep -oE` weiterreichen 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: true` ab, und die UI zeigt eine Warnung, statt den Tab einzufrieren.
- Eigene Implementierung des Ersetzungs-Templates
- Der Ersetzen-Tab parst $1..$N, $&, $`, $', $$ und $
selbst, statt an `String.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 `literal` zurü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; `pattern` trifft überall. Die falsche Wahl ist der häufigste Bug in der Formular-Validierung: ein fehlendes `^` lässt ein vorangestelltes `attacker.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 `\w` Surrogat-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
- `(?
\d{4})-(? \d{2})` ist selbstdokumentierend. Sechs Monate später, wenn Sie den regulären Ausdruck wieder lesen, ist `m.groups.year` offensichtlich das Jahr — `m[1]` nicht. Ersetzungs-Templates mit $ ü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?
Was bewirken die einzelnen Flags g, i, m, s, u, y, d?
Wie schreibe ich Erfassungsgruppen, und wie verweise ich auf sie zurück?
Wie funktionieren Lookahead und Lookbehind, und wofür sind sie gut?
Warum hängt mein regulärer Ausdruck den Browser auf, und was ist katastrophales Backtracking?
Wie unterscheidet sich dieser Regex-Tester von regex101.com?
Wie escape ich Sonderzeichen wie . | ( ) [ ] { } * + ? ^ $ \?
Kann ich einen regulären Ausdruck per Link mit einem Kollegen teilen?
Unterstützt der Tester Unicode, Emoji und nicht-lateinische Schriften?
Was ist der Unterschied zwischen .match, .matchAll, .replace und .split mit einem regulären Ausdruck?
Warum funktioniert mein Python- oder Java-Regex hier nicht?
Gibt es eine maximale Textgröße oder Trefferanzahl?
Verwandte Werkzeuge
Alle Werkzeuge anzeigen →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.
Kostenloser Wortzähler & Zeichenzähler
Textverarbeitung
Zählen Sie Wörter, Zeichen, Sätze, Absätze und Lesezeit sofort. Echtzeit-Wortzähler mit Prüfung der Limits für Twitter, Meta-Description und Instagram. Kostenlos, privat, ohne Anmeldung.
Zahlensystem-Konverter — Binär, Hex, Dezimal & Oktal
Konvertierungswerkzeuge
Zahlen zwischen Binär, Hexadezimal, Dezimal, Oktal und beliebigen Basen (2–36) sofort konvertieren. Kostenlos, privat, ohne Anmeldung — alles läuft in Ihrem Browser.
Base64-Dekodierer & -Kodierer
Kodierung & Formatierung
Base64 online kostenlos dekodieren und kodieren. Echtzeitkonvertierung mit voller UTF-8- und Emoji-Unterstützung. 100 % privat — läuft in Ihrem Browser. Keine Anmeldung nötig.
Crontab Generator & Cron-Ausdruck Builder
Datum & Uhrzeit
Erstellen, validieren und entschlüsseln Sie Cron-Ausdrücke im Browser. Live-Vorschau der nächsten Läufe in lokaler Zeit oder UTC. POSIX-5-Feld-Syntax, Voreinstellungen, Klartextbeschreibung. Kostenlos, privat, ohne Anmeldung.
CSV-zu-JSON-Konverter
Kodierung & Formatierung
CSV im Browser nach JSON konvertieren. RFC 4180, Typinferenz, Kopfzeile, Big-Int-sicher. 100 % privat, kein Upload.