Regex Tester

Reguläre Ausdrücke gegen einen String testen und alle Treffer farbig hervorgehoben sehen

Beispiel ausprobieren

Pattern

//g

Teststring

Läuft lokal · Sicher zum Einfügen von Secrets

Was ist ein regulärer Ausdruck?

Ein regulärer Ausdruck (Regex oder Regexp) ist eine Zeichenfolge, die ein Suchmuster definiert. Regex-Tester ermöglichen es, ein Pattern zu schreiben, es gegen Beispieltext auszuführen und alle Treffer in Echtzeit farbig hervorgehoben zu sehen. Das Konzept geht auf die Arbeit des Mathematikers Stephen Kleene zu regulären Sprachen in den 1950er-Jahren zurück; Ken Thompson baute 1968 die erste Regex-Engine in den QED-Texteditor ein.

Eine Regex-Engine liest ein Pattern von links nach rechts und verbraucht dabei Eingabezeichen. Bei einem Teilmisserfolg verwendet sie Backtracking: Die Engine geht zurück und versucht alternative Wege durch das Pattern. Einige Engines (wie RE2 in Go) vermeiden Backtracking vollständig, indem sie Patterns in deterministische endliche Automaten (DFA) umwandeln. Das garantiert lineare Laufzeit, verzichtet aber auf Features wie Rückwärtsreferenzen.

Regex-Syntax ist nur locker standardisiert. PCRE (Perl Compatible Regular Expressions) ist das verbreitetste Format, unterstützt von PHP, Pythons re-Modul und JavaScript mit geringfügigen Unterschieden. POSIX definiert eine eingeschränktere Syntax, die von grep und sed verwendet wird. Diese Unterschiede sind relevant beim Portieren von Patterns zwischen Sprachen: Ein Lookahead, der in JavaScript funktioniert, lässt sich in Gos RE2-Engine möglicherweise gar nicht kompilieren.

Warum einen Online-Regex-Tester verwenden?

Regex in einer Code-Datei zu schreiben bedeutet, nach jeder Anpassung zu speichern, auszuführen und die Ausgabe zu prüfen. Ein browserbasierter Regex-Tester schließt diese Feedback-Schleife auf null: Man tippt und sieht sofort die Treffer.

Echtzeit-Trefferhighlighting
Jede Eingabe aktualisiert die Treffer sofort. Du siehst, welche Teile des Textes matchen, welche Capture-Gruppen belegt sind und genau wo jeder Treffer beginnt und endet. Kein Kompilieren-Ausführen-Debuggen-Zyklus.
🔒
Datenschutz-first
Das Pattern-Matching läuft im Browser über die JavaScript-RegExp-Engine. Kein Text und kein Pattern wird an einen Server übertragen. Das ist wichtig, wenn du gegen Log-Dateien, Kundendaten oder API-Antworten mit sensiblen Informationen testest.
🔍
Visuelle Trefferinspektion
Treffer werden inline hervorgehoben, mit ihren Positionen und den Werten der Capture-Gruppen. Die visuelle Darstellung macht es leichter, Off-by-one-Fehler in Quantoren oder fehlende Anker zu entdecken.
🌐
Kein Login oder Installation nötig
Funktioniert auf jedem Gerät mit einem modernen Browser. Kein Konto, keine Erweiterung, kein IDE-Plugin. Seite öffnen, Pattern und Text einfügen, und loslegen.

Anwendungsfälle für den Regex Tester

Frontend-Eingabevalidierung
Patterns für E-Mail-, Telefonnummer- oder Kreditkartenfelder erstellen und verifizieren, bevor sie in HTML5-Pattern-Attribute oder JavaScript-Validierungslogik eingebettet werden.
Backend-Log-Parsing
Regex-Patterns schreiben, die Timestamps, Fehlercodes oder IP-Adressen aus Anwendungslogs extrahieren. Gegen echte Log-Samples testen, um sicherzustellen, dass das Pattern die richtigen Gruppen erfasst.
DevOps & Infrastruktur
Regex in Nginx-Location-Blöcken, Apache-Rewrite-Regeln oder Prometheus-Alerting-Regeln debuggen. Ein falsches Pattern in einer Server-Konfiguration kann das Routing unterbrechen oder Alerts vollständig auslassen.
QA & Test-Automatisierung
Prüfen, ob Response-Bodies oder HTML-Ausgaben in End-to-End-Test-Assertions den erwarteten Patterns entsprechen. Das Regex hier vorab testen, bevor es in die Test-Suite übernommen wird.
Datenextraktions-Pipelines
Patterns für die Extraktion strukturierter Felder aus unstrukturiertem Text prototypisch entwickeln: Produktpreise scrapen, CSV-Sonderfälle parsen oder Metadaten aus E-Mail-Headern extrahieren.
Reguläre Ausdrücke lernen
Mit Metazeichen, Quantoren und Gruppen gegen Beispielstrings experimentieren. Direktes visuelles Feedback macht Regex-Syntax leichter erlernbar als das reine Lesen von Dokumentation.

Regex-Syntax-Kurzreferenz

Die folgende Tabelle zeigt die gebräuchlichsten Regex-Token. Sie funktionieren in JavaScript, Python, Go, PHP und den meisten PCRE-kompatiblen Engines. Sprachspezifische Erweiterungen (wie Pythons konditionale Patterns oder JavaScripts Named Groups mit \k-Syntax) sind im Abschnitt Code-Beispiele erläutert.

PatternNameBeschreibung
.Any characterMatches any single character except newline (unless s flag is set)
\dDigitMatches [0-9]
\wWord characterMatches [a-zA-Z0-9_]
\sWhitespaceMatches space, tab, newline, carriage return, form feed
\bWord boundaryMatches the position between a word character and a non-word character
^Start of string/lineMatches the start of the input; with m flag, matches start of each line
$End of string/lineMatches the end of the input; with m flag, matches end of each line
*Zero or moreMatches the preceding token 0 or more times (greedy)
+One or moreMatches the preceding token 1 or more times (greedy)
?OptionalMatches the preceding token 0 or 1 time
{n,m}Quantifier rangeMatches the preceding token between n and m times
()Capturing groupGroups tokens and captures the matched text for back-references
(?:)Non-capturing groupGroups tokens without capturing the matched text
(?=)Positive lookaheadMatches a position followed by the given pattern, without consuming it
(?<=)Positive lookbehindMatches a position preceded by the given pattern, without consuming it
[abc]Character classMatches any one of the characters inside the brackets
[^abc]Negated classMatches any character not inside the brackets
|AlternationMatches the expression before or after the pipe

Regex-Flags erklärt

Flags (auch Modifier genannt) ändern, wie die Engine das Pattern verarbeitet. In JavaScript werden sie nach dem schließenden Schrägstrich angehängt: /pattern/gi. In Python werden sie als zweites Argument übergeben: re.findall(pattern, text, re.IGNORECASE | re.MULTILINE). Nicht alle Flags sind in jeder Sprache verfügbar.

FlagNameVerhalten
gGlobalFind all matches, not just the first one
iCase-insensitiveLetters match both uppercase and lowercase
mMultiline^ and $ match start/end of each line, not just the whole string
sDot-all. matches newline characters as well
uUnicodeTreat the pattern and subject as a Unicode string; enables \u{FFFF} syntax
yStickyMatches only from the lastIndex position in the target string

Code-Beispiele

Funktionierende Regex-Beispiele in JavaScript, Python, Go und auf der Kommandozeile. Jedes Beispiel zeigt Pattern-Konstruktion, Match-Extraktion und Ausgabe.

JavaScript
// Match all email addresses in a string
const text = 'Contact us at support@example.com or sales@example.com'
const emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g

const matches = text.matchAll(emailRegex)
for (const match of matches) {
  console.log(match[0], 'at index', match.index)
}
// → "support@example.com" at index 14
// → "sales@example.com" at index 37

// Named capture groups (ES2018+)
const dateRegex = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/
const result = '2026-03-30'.match(dateRegex)
console.log(result.groups)
// → { year: "2026", month: "03", day: "30" }

// Replace with a callback
'hello world'.replace(/\b\w/g, c => c.toUpperCase())
// → "Hello World"
Python
import re

# Find all IPv4 addresses
text = 'Server 192.168.1.1 responded, fallback to 10.0.0.255'
pattern = r'\b(?:\d{1,3}\.){3}\d{1,3}\b'

matches = re.findall(pattern, text)
print(matches)  # → ['192.168.1.1', '10.0.0.255']

# Named groups and match objects
date_pattern = r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})'
m = re.search(date_pattern, 'Released on 2026-03-30')
if m:
    print(m.group('year'))   # → '2026'
    print(m.group('month'))  # → '03'

# Compile for repeated use (faster in loops)
compiled = re.compile(r'\b[A-Z][a-z]+\b')
words = compiled.findall('Hello World Foo bar')
print(words)  # → ['Hello', 'World', 'Foo']
Go
package main

import (
	"fmt"
	"regexp"
)

func main() {
	// Find all matches
	re := regexp.MustCompile(`\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b`)
	text := "Contact support@example.com or sales@example.com"
	matches := re.FindAllString(text, -1)
	fmt.Println(matches)
	// → [support@example.com sales@example.com]

	// Named capture groups
	dateRe := regexp.MustCompile(`(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})`)
	match := dateRe.FindStringSubmatch("2026-03-30")
	for i, name := range dateRe.SubexpNames() {
		if name != "" {
			fmt.Printf("%s: %s\n", name, match[i])
		}
	}
	// → year: 2026
	// → month: 03
	// → day: 30

	// Replace with a function
	result := re.ReplaceAllStringFunc(text, func(s string) string {
		return "[REDACTED]"
	})
	fmt.Println(result)
	// → Contact [REDACTED] or [REDACTED]
}
CLI (grep / sed)
# Find lines matching an IP address pattern
grep -E '\b([0-9]{1,3}\.){3}[0-9]{1,3}\b' access.log

# Extract email addresses from a file
grep -oE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' contacts.txt

# Replace dates from YYYY-MM-DD to DD/MM/YYYY using sed
echo "2026-03-30" | sed -E 's/([0-9]{4})-([0-9]{2})-([0-9]{2})/\3\/\2\/\1/'
# → 30/03/2026

# Count matches per file in a directory
grep -rcE 'TODO|FIXME|HACK' src/
# → src/main.js:3
# → src/utils.js:1

Häufig gestellte Fragen

Was ist der Unterschied zwischen Regex und Glob-Patterns?
Glob-Patterns (wie *.txt oder src/**/*.js) sind eine vereinfachte Wildcard-Syntax für Dateipfad-Matching in Shells und Build-Tools. Sie unterstützen * (beliebige Zeichen), ? (ein Zeichen) und [] (Zeichenklassen), verfügen aber nicht über Quantoren, Gruppen, Lookaheads oder Alternation. Regex ist deutlich ausdrucksstärker und arbeitet auf beliebigem Text, nicht nur auf Dateipfaden. Ein Glob-Pattern *.json entspricht grob dem Regex ^.*\.json$.
Wie matche ich einen literalen Punkt oder eine Klammer in Regex?
Den Charakter mit einem Backslash voranstellen: \. matcht einen literalen Punkt, \[ matcht eine literale eckige Klammer. Innerhalb einer Zeichenklasse [] ist ein Punkt bereits literal und muss nicht escaped werden. Ein häufiger Fehler ist das Schreiben von 192.168.1.1 ohne die Punkte zu escapen — das matcht dann auch 192x168y1z1, weil . für "beliebiges Zeichen" steht.
Werden meine Testdaten an einen Server gesendet?
Nein. Dieses Tool führt das Regex-Matching vollständig im Browser über die JavaScript-RegExp-Engine aus. Es werden keine Netzwerkanfragen mit deinem Text oder Pattern gemacht. Das lässt sich im Netzwerk-Tab der Browser-DevTools nachprüfen.
Warum funktioniert mein Regex in JavaScript, aber nicht in Python?
JavaScript und Python verwenden unterschiedliche Regex-Engines mit leicht abweichenden Funktionsumfängen. JavaScript unterstützt \d, Lookaheads (?=) und Lookbehinds (?<=) seit ES2018, jedoch keine konditionalen Patterns, atomare Gruppen oder possessive Quantoren. Pythons re-Modul unterstützt keine \p{} Unicode-Property-Klassen (dafür das Third-party-Modul regex verwenden). Immer in der Engine der Zielsprache testen oder deren Regex-Dokumentation konsultieren.
Was verursacht katastrophales Backtracking in Regex?
Katastrophales Backtracking tritt auf, wenn ein Pattern verschachtelte Quantoren enthält, die eine exponentielle Anzahl von Match-Pfaden erzeugen. Das klassische Beispiel ist (a+)+ auf einen String aus a's gefolgt von einem nicht-matchenden Zeichen. Die Engine probiert jeden möglichen Weg, die a's auf innere und äußere Gruppen aufzuteilen, bevor sie scheitert. Abhilfe schaffen atomare Gruppen (?>), possessive Quantoren a++ oder das Umschreiben des Patterns zur Vermeidung mehrdeutiger Wiederholungen.
Kann ich Regex zum Parsen von HTML verwenden?
Regex kann einfache Werte aus HTML-Fragmenten extrahieren, etwa das href-Attribut aus einem einzelnen <a>-Tag. Für vollständiges HTML-Parsing sollte ein richtiger Parser verwendet werden (DOMParser in JavaScript, BeautifulSoup in Python oder html/template in Go). HTML ist eine kontextfreie Grammatik, und Regex verarbeitet reguläre Grammatiken. Verschachtelte Tags, optionale Attribute und selbstschließende Elemente erzeugen Patterns, die Regex nicht zuverlässig matchen kann.
Was ist der Unterschied zwischen gierigen und faulen Quantoren?
Ein gieriger Quantor (* oder +) matcht so viele Zeichen wie möglich und führt dann Backtracking durch, wenn der Rest des Patterns fehlschlägt. Ein fauler Quantor (*? oder +?) matcht so wenige Zeichen wie möglich und erweitert sich nur bei Bedarf. Für die Eingabe <b>eins</b><b>zwei</b> matcht das gierige Pattern <b>.*</b> den gesamten String vom ersten <b> bis zum letzten </b>, während das faule Pattern <b>.*?</b> <b>eins</b> und <b>zwei</b> separat matcht.