Testen Sie reguläre Ausdrücke online. Analysieren Sie Übereinstimmungen, korrigieren Sie Fehler und erstellen Sie effektive Muster zur Datensuche.
Keine Übereinstimmungen gefunden
Kein nicht übereinstimmender Inhalt
Ermöglicht das Überprüfen von RegExp-Mustern in Echtzeit, was die Entwicklung und das Debugging komplexer Suchmuster vereinfacht.
Ermöglicht die Berücksichtigung von Groß-/Kleinschreibung, globaler Suche, mehrzeiligem Modus und anderen in Programmiersprachen verwendeten Einstellungen.
Ermöglicht die schnelle Erstellung von Ausdrücken für die automatische Verarbeitung großer Textmengen, Protokolle und HTML-Codes.
Reguläre Ausdrücke (Regex) sind eine Mustersprache zur Suche, Validierung und Verarbeitung von Text.
Mit Regex können Sie:
bestimmte Textfragmente finden (z. B. E-Mail-Adressen, URLs, Zahlen)
Datenformate validieren (Formularprüfung)
Text ersetzen und bereinigen
strukturierte Daten aus Strings extrahieren
Regex wird широко in der Entwicklung, Datenanalyse, SEO und Automatisierung eingesetzt.
Dieses Tool ermöglicht es, reguläre Ausdrücke in Echtzeit zu testen und die Ergebnisse sofort zu sehen.
Damit können Sie:
prüfen, ob ein Text einem Muster entspricht
alle Übereinstimmungen in einem Text anzeigen
komplexe Ausdrücke debuggen
verschiedene Regex-Varianten ohne Code testen
Reguläre Ausdrücke sind nicht vollständig universell. Die Syntax hängt von der Programmiersprache und der verwendeten Engine ab.
Engine | Verwendung | Besonderheiten |
|---|---|---|
JavaScript (ECMAScript) | Browser, Node.js | Eingeschränkter Lookbehind (abhängig von Version) |
PCRE | PHP, viele Tools | Eine der leistungsfähigsten Engines |
Python (re) | Python | Einige PCRE-Funktionen fehlen |
Java (Pattern) | Java | Strenge Syntax |
.NET | C# | Erweiterte Funktionen |
Testen Sie Regex immer in der Zielumgebung. Achten Sie besonders auf Unterschiede bei Lookbehind und Unicode-Unterstützung. Für plattformübergreifende Lösungen sollten Sie einfachere Muster verwenden.
Flags sind Parameter, die das Verhalten eines Musters verändern.
Flag | Bedeutung |
|---|---|
i | Groß-/Kleinschreibung ignorieren |
g | Globale Suche |
m | Mehrzeilenmodus |
s | Dotall (schließt \n in . ein) |
u | Unicode |
Typen | Symbol | Beschreibung |
|---|---|---|
Anker (Positionen) | ^ | Anfang der Zeichenkette |
Anker (Positionen) | $ | Ende der Zeichenkette |
Anker (Positionen) | \b | Wortgrenze |
Anker (Positionen) | \B | Keine Wortgrenze |
Metazeichen | . | Beliebiges Zeichen außer Zeilenumbruch (\n) |
Metazeichen | | | ODER-Operator |
Metazeichen | \ | Escape-Zeichen |
Literale | a | Zeichen „a“ |
Literale | ab | Zeichenkette „ab“ |
Quantifizierer | * | 0 oder mehr Wiederholungen |
Quantifizierer | ? | 0 oder 1 Wiederholung |
Quantifizierer | + | 1 oder mehr Wiederholungen |
Quantifizierer | {5} | Genau 5 Wiederholungen |
Quantifizierer | {5,} | 5 oder mehr Wiederholungen |
Quantifizierer | {5,10} | Zwischen 5 und 10 Wiederholungen |
Zeichenklassen | \s | Leerzeichen |
Zeichenklassen | \S | Kein Leerzeichen |
Zeichenklassen | \w | Wortzeichen (alphanumerisch + Unterstrich) |
Zeichenklassen | \W | Kein Wortzeichen |
Zeichenklassen | \d | Ziffer |
Zeichenklassen | \D | Keine Ziffer |
Escape-Sequenzen | [\b] | Backspace |
Escape-Sequenzen | \c | Steuerzeichen |
Escape-Sequenzen | \n | Zeilenumbruch |
Escape-Sequenzen | \t | Tabulator |
Escape-Sequenzen | \r | Wagenrücklauf |
Escape-Sequenzen | \ZZZ | Oktalzeichen |
Escape-Sequenzen | \xZZ | Hexadezimalzeichen |
Escape-Sequenzen | \0 | Null-Zeichen |
Escape-Sequenzen | \v | Vertikaler Tabulator |
Gruppen | (xyz) | Capturing Group |
Gruppen | (?:xyz) | Non-Capturing Group |
Mengen und Bereiche | [xyz] | Beliebiges Zeichen aus x, y oder z |
Mengen und Bereiche | [^xyz] | Kein Zeichen aus x, y oder z |
Mengen und Bereiche | [a-q] | Bereich von a bis q |
Mengen und Bereiche | [0-7] | Bereich von 0 bis 7 |
Ersetzungsmuster | $` | Text vor dem Match |
Ersetzungsmuster | $' | Text nach dem Match |
Ersetzungsmuster | $+ | Letzte gefundene Gruppe |
Ersetzungsmuster | $& | Gesamter Treffer |
Ersetzungsmuster | $n | n-te Gruppe (z. B. $1, $2) |
Lookarounds | (?=xyz) | Positiver Lookahead |
Lookarounds | (?!xyz) | Negativer Lookahead |
Lookarounds | (?<=xyz) | Positiver Lookbehind |
Lookarounds | (?<!xyz) | Negativer Lookbehind |
Kommentare | (?#comment) | Kommentar (wird ignoriert) |
Aufgabe | Regex |
|---|---|
Nur Ziffern | ^\d+$ |
Nur lateinische Buchstaben | ^[A-Za-z]+$ |
Datum (DD.MM.YYYY) | \d{2}\.\d{2}\.\d{4} |
Domain | ^[a-z0-9.-]+\.[a-z]{2,}$ |
URL | https?:\/\/[^\s]+ |
Slug | ^[a-z0-9-]+$ |
E-Mail (einfach) | ^[^\s@]+@[^\s@]+\.[^\s@]+$ |
E-Mail (streng) | ^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$ |
Telefon (allgemein) | ^\+?\d{7,15}$ |
HTML-Tags | <[^>]+> |
Starkes Passwort | ^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[\W_]).{12,}$ |
UUID | ^[0-9a-fA-F-]{36}$ |
HEX-Farbe | ^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$ |
IP (IPv4) | ^(\d{1,3}\.){3}\d{1,3}$ |
MAC-Adresse | ^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$ |
Reguläre Ausdrücke wirken oft einfach, bergen aber viele versteckte Feinheiten. Im Folgenden werden häufige Fehler aufgeführt, die zu falschen Ergebnissen führen.
Fehlendes Escaping: . steht für jedes Zeichen → verwenden Sie \.
Falsche Verwendung von Quantifizierern: *, +, {} gelten für das vorherige Element
Verwechslung von greedy und lazy: .* ist greedy → verwenden Sie .*? für minimale Treffer
Fehlende Anker ^ und $: sonst wird innerhalb der Zeichenkette gesucht
Groß-/Kleinschreibung: "Test" ≠ "test" → ggf. i-Flag verwenden
Missverständnis bei Leerzeichen: \s umfasst auch Tabs, Zeilenumbrüche usw.
Verwendung von \w für Unicode: meist nur [A-Za-z0-9_]
Versuch, komplexe Formate (HTML, JSON) mit Regex zu parsen → besser Parser verwenden
Zu komplexe Ausdrücke: schwer wartbar und fehleranfällig
Verschachtelte Quantifizierer: z. B. (.*)+ kann zu „catastrophic backtracking“ führen
Unbegrenzte Muster: .* ohne Einschränkungen kann bei großen Texten langsam sein
Beachten Sie, dass reguläre Ausdrücke in diesem Tool gemäß dem ECMAScript-Standard (JavaScript RegExp) verarbeitet werden. Dies bedeutet, dass das Verhalten der Muster dem entspricht, wie sie im Browser oder in JavaScript-Code funktionieren. Einige Konstrukte, wie z.B. das Escaping von Zeichen (/ und /), können sich gleich verhalten, auch wenn sie unterschiedlich aussehen. Wenn Sie an reguläre Ausdrücke in anderen Sprachen (z.B. Python, PHP, .NET oder POSIX) gewöhnt sind, beachten Sie, dass es dort Unterschiede in der Syntax und der Abgleichlogik geben kann.
Dieses Tool ermöglicht das Testen von regulären Ausdrücken (RegEx) und deren Funktionsprüfung. RegEx wird häufig in der Programmierung, Datenverarbeitung und SEO-Analyse verwendet.
Damit können Textmuster gesucht, ersetzt und analysiert werden, was die Arbeit mit großen Datenmengen vereinfacht.
Reguläre Ausdrücke (Regex) sind mächtige Musterabgleichstools zum Suchen, Validieren und Manipulieren von Text. Sie sind unerlässlich für die Datenvalidierung, Suchoperationen und Textverarbeitungsaufgaben.
Unser Regex-Tester ermöglicht es Ihnen, Muster und Testzeichenfolgen einzugeben, um Übereinstimmungen in Echtzeit zu sehen. Sie können mit verschiedenen Mustern experimentieren und sehen, welche Teile Ihres Textes dem Ausdruck entsprechen.
Gängige Muster umfassen die Validierung von E-Mail, Telefonnummern, Daten, URLs und Postleitzahlen. Lernen Sie grundlegende Metazeichen wie ., *, +, ?, ^, $ und Zeichenklassen wie \d, \w, \s.
Häufig verwendete Flags sind i (Groß-/Kleinschreibung ignorieren), g (globale Suche), m (Mehrzeilenmodus) und u (Unicode-Unterstützung). Sie helfen, die Suche und den Abgleich genauer zu steuern.
Komplexe Muster mit Backtracking können bei großen Texten langsam sein. Optimieren Sie, indem Sie spezifisch sind, verschachtelte Quantifizierer vermeiden und, wenn möglich, Anker (^ und $) verwenden. Testen Sie die Leistung mit realistischen Datengrößen.
Fanggruppen sind Teile eines regulären Ausdrucks (definiert durch Klammern), die es ermöglichen, bestimmte Unterabschnitte des Textes zu extrahieren, die dem Muster entsprechen. Dies ist nützlich zum Neuformatieren oder Extrahieren spezifischer Daten.
Ein 'gieriger' Quantifizierer (z. B. `.*`) versucht, so viele Zeichen wie möglich abzugleichen. Ein 'fauler' Quantifizierer (z. B. `.*?`) versucht, so wenige Zeichen wie möglich abzugleichen. Die Wahl hängt vom gewünschten Abgleichsverhalten ab.
Die meisten modernen Implementierungen regulärer Ausdrücke unterstützen Unicode, was das Abgleichen von Zeichen in verschiedenen Sprachen und Alphabeten ermöglicht. Die genaue Unterstützung kann jedoch zwischen Programmiersprachen und Tools variieren.
