Doku · RegExViz

Diese Doku ist identisch mit dem Hilfesystem in der RegExViz-App (⌘ ⇧ ?). Alle 14 Topics werden hier am Stück angeboten — du kannst stöbern, suchen oder direkt zu einem Abschnitt springen. Jedes Topic ist außerdem als eigene Seite unter /hilfe/<topic>/ verfügbar.

📚 In der App wird zu jedem Beispiel eine Live-Visualisierung angezeigt — der gleiche Layout-Algorithmus wie auf der Visualisierung-Seite, nur miniaturisiert pro Beispiel.

📑 Inhalt

📖 RegEx-Grundlagen
Was sind reguläre Ausdrücke und wie liest man sie?
🔁 Quantifier
Wie oft soll ein Element matchen?
🔠 Zeichenklassen
Welche Zeichen sind erlaubt?
⚓ Anker
Wo im Text soll matched werden?
🪺 Gruppen
Pattern bündeln und Teiltreffer extrahieren
🌿 Alternation
Mehrere Möglichkeiten mit |
👁️ Lookarounds
Bedingungen, ohne zu konsumieren
🛡️ Escapes
Sonderzeichen wörtlich matchen
🚩 Flags (i, m, s)
Globales Verhalten der Engine ändern
🎨 Visualisierung
Wie liest man das Diagramm?
🐞 Debugger
Schritt für Schritt durch den Match-Lauf
🤖 AI-Assistent
Patterns generieren oder ändern lassen
⌨️ Tastaturkürzel
Übersicht der Shortcuts
🖥️ Bedienoberfläche
Das 3-Spalten-Layout

📖 RegEx-Grundlagen

Ein regulärer Ausdruck (RegEx) ist ein kleines Programm, das gegen Text läuft und Treffer findet. Buchstaben, Ziffern und die meisten Symbole matchen sich selbst. Sonderzeichen wie ., *, +, ?, (, ) haben eine spezielle Bedeutung. Wer sie als Text matchen will, muss sie mit einem Backslash escapen: \. für einen Punkt.

Engine in RegExViz

Das Matching erfolgt mit NSRegularExpression (ICU-Engine). Diese unterstützt klassische Erweiterungen wie Lookaheads, Lookbehinds, Backreferences und named groups.

Beispiel 1 · Literal — Pattern Hallo matcht das Wort „Hallo" exakt. Beispiel 2 · Beliebiges Zeichen — Pattern h.llo — der Punkt . matcht ein einzelnes beliebiges Zeichen außer Newline.

🔁 Quantifier

Quantifier hängen direkt hinter dem Element, das sich wiederholen soll.

Symbol	Bedeutung
`?`	0 oder 1 mal (optional)
`*`	0 oder mehr
`+`	1 oder mehr
`{n}`	genau n
`{n,}`	mindestens n
`{n,m}`	n bis m mal

Greedy vs. lazy: Standardmäßig sind Quantifier greedy — sie nehmen so viel wie möglich. Mit angehängtem ? werden sie lazy.

Beispiel	Pattern	Match
Optional	`colou?r`	`color`, `colour`
≥ 1	`\d+`	mind. eine Ziffer
Genau 4	`\d{4}`	`2026`
n..m	`\d{2,4}`	`12`, `123`, `1234`
Greedy	`<.*>`	nimmt alles bis zum letzten `>`
Lazy	`<.*?>`	nimmt alles bis zum nächsten `>`

🔠 Zeichenklassen

In [...] listest du Zeichen oder Bereiche auf. Mit ^ am Anfang wird die Klasse negiert.

Vordefinierte Kürzel

Symbol	Bedeutung
`\d`	eine Ziffer (`[0-9]`)
`\D`	keine Ziffer
`\w`	Wortzeichen (`[A-Za-z0-9_]`)
`\W`	kein Wortzeichen
`\s`	Whitespace
`\S`	kein Whitespace
`.`	beliebiges Zeichen außer Newline

Beispiele: [aeiou] (Vokal), [a-zA-Z]+ (lat. Buchstaben), [^0-9 ]+ (alles außer Ziffern und Leerzeichen), \w+, \s+.

⚓ Anker

Anker matchen keine Zeichen, sondern Positionen im Text. Sie konsumieren also nichts.

Symbol	Bedeutung
`^`	Anfang (mit Flag `m` Anfang einer Zeile)
`$`	Ende (mit Flag `m` Ende einer Zeile)
`\b`	Wortgrenze (Übergang `\w` ↔ `\W`)
`\B`	keine Wortgrenze
`\A`	Stringanfang (immer, unabhängig vom Multiline-Flag)
`\z`	Stringende

Beispiele: ^Foo (Zeilenanfang), \bcat\b (nur das Wort „cat", nicht „catalog").

🪺 Gruppen

Mit (…) bildest du eine Gruppe. Sie erfasst den Treffer und kann später als Capture-Gruppe abgerufen oder via \1, \2, … rückbezogen werden.

Form	Bedeutung
`(...)`	Capturing — speichert Treffer
`(?:...)`	Non-Capturing — gruppiert ohne zu speichern
`(?<name>...)`	Named — speichert unter Namen
`(?>...)`	Atomar — verhindert Backtracking

Beispiele:

(\d{4})-(\d{2})-(\d{2}) — drei Capture-Gruppen (Jahr/Monat/Tag)
(?:foo|bar)+ — gruppiert ohne zu erfassen
(?<year>\d{4}) — benannte Gruppe
\b(\w+)\s+\1\b — Backreference auf erste Gruppe (findet doppelte Wörter)

🌿 Alternation

Mit | baust du Alternativen. Klammere sie meist mit (?:…), damit der Scope klar ist und du Quantifier auf die ganze Alternation anwenden kannst.

👁️ Lookarounds

Form	Bedeutung
`(?=…)`	Positiver Lookahead — fordert, dass etwas folgt
`(?!…)`	Negativer Lookahead — fordert, dass etwas NICHT folgt
`(?<=…)`	Positiver Lookbehind
`(?<!…)`	Negativer Lookbehind

Alle Lookarounds konsumieren keine Zeichen — der Match-Cursor bleibt stehen.

Beispiele:

\d+(?= EUR) — Zahl, die von „ EUR" gefolgt wird
(?<=#)\w+ — Wort nach # (Hashtag-Inhalt ohne #)

🛡️ Escapes

Sonderzeichen wie ., *, +, ?, (, ), [, ], {, }, |, ^, $, \ werden mit einem vorangestellten Backslash escaped.

In Swift-String-Literalen muss der Backslash selbst escaped werden — am bequemsten sind Raw-Strings:

let pattern = #"\d{4}-\d{2}-\d{2}"#

Beispiele: \.\d{2} (echter Punkt + zwei Ziffern), $\d+$ (Zahl in Klammern).

🚩 Flags (i, m, s)

Flag	Bedeutung
`i`	caseInsensitive — Groß-/Kleinschreibung egal
`m`	multiline — `^` und `$` matchen Zeilenanfang/-ende
`s`	dotAll — der Punkt `.` matcht auch Newlines

In RegExViz schaltest du diese Flags mit den drei kleinen Buttons rechts oberhalb des Pattern-Editors.

🎨 Visualisierung

Jeder Bestandteil des Patterns wird als farbiger Knoten dargestellt; Verbindungen zeigen die Reihenfolge.

Farbe	Bedeutung
Blau	Literal-Zeichen
Lila	Escape-Sequenzen wie `\d`, `\w`
Grün	Anker (`^`, `$`, `\b` …)
Orange	Zeichenklassen
Rot	negierte Zeichenklassen
Gestricheltes Rechteck	Gruppe (Capturing/Named/Lookaround)
Orange Pille unter Knoten	Quantifier (Mouseover für Klartext)
Grüner / roter Kreis	Start- / End-Anker des Diagramms

In der App ist jeder Knoten und jede Gruppen-Box klickbar — ein Detail-Popover zeigt Titel, Syntax, Erklärung, ein Beispiel und einen Link in das passende Hilfe-Topic.

🐞 Debugger

Der Debugger zerlegt einen kompletten Match-Lauf in einzelne Schritte:

Pattern kompilieren — NSRegularExpression mit den gewählten Flags
Suche starten — am Stringanfang
Treffer #N gefunden — Position und Länge
Capture-Gruppe N erfasst — pro Gruppe ein Schritt
Suche abgeschlossen — alle Treffer ermittelt

Bedienung über die Pfeil-Buttons rechts oben oder direkt per Klick auf einen Schritt in der Liste.

🤖 AI-Assistent

Ganz unten im rechten Bereich findest du eine 3-zeilige Eingabe für den AI-Assistenten. Beschreibe in natürlicher Sprache, was du brauchst — der Assistent ruft die konfigurierte AI-API (Default: DeepSeek) auf und antwortet mit einem JSON-Objekt, das Pattern, Titel, Erklärung und Flags enthält.

⌘ + Enter sendet die Anfrage.
Mit „automatisch anwenden" landet das Pattern direkt im Editor.
„Als neuen RegEx speichern" legt einen neuen Eintrag in der Bibliothek an.
Der API-Key wird in den Einstellungen → KI hinterlegt.

In Debug-Builds ist ein Test-Key vorbelegt. Für eigene Builds bitte einen eigenen Key bei https://platform.deepseek.com hinterlegen.

Antwort-Schema

{
  "pattern": "...",
  "title": "...",
  "explanation": "...",
  "flags": { "caseInsensitive": false, "multiline": false, "dotAll": false }
}

⌨️ Tastaturkürzel

Shortcut	Aktion
`⌘ ,`	Einstellungen öffnen
`⌘ N`	Neuen RegEx anlegen
`⌘ ⇧ ?`	Hilfe-Fenster öffnen
`⌘ ↩` (Enter)	AI-Anfrage in der Prompt-Bar senden

🖥️ Bedienoberfläche

Sidebar (links) — filtert die Bibliothek nach Kategorien oder zeigt nur eigene Einträge.

Liste (Mitte) — zeigt alle RegExe der gewählten Kategorie. Über die Toolbar lässt sich ein neuer RegEx anlegen, über die Suchleiste kann nach Titel, Pattern oder Beschreibung gefiltert werden.

Detail (rechts) — Pattern-Editor, Testtext-Editor mit Live-Highlighting, Tabs für Visualisierung, Treffer, Debugger und Erklärung — sowie ganz unten die AI-Eingabe.