Regulaere Ausdruecke meistern 2026

"Regulaere Ausdruecke sind schwierig" - das stimmt. Aber sobald Sie sie beherrschen, koennen Sie die Textverarbeitungszeit um 90% reduzieren.

Diese Anleitung deckt die am haeufigsten verwendeten Regex-Muster in der Praxis mit Beispielen ab.

---

Regex-Grundlagen

Grundlegende Syntax

Zeichenklassen

[abc]     - Eines von a, b, c
[^abc]    - Ausser a, b, c
[a-z]     - Von a bis z
[A-Z]     - Von A bis Z
[0-9]     - Von 0 bis 9
[a-zA-Z]  - Alle Buchstaben

Quantifizierer

{n}       - Genau n
{n,}      - n oder mehr
{n,m}     - Zwischen n und m
*         - 0 oder mehr ({0,})
+         - 1 oder mehr ({1,})
?         - 0 oder 1 ({0,1})

Gruppen und Erfassung

(abc)     - Erfassungsgruppe
(?:abc)   - Nicht-erfassende Gruppe
(?<name>abc) - Benannte Gruppe
\1        - Rueckverweis auf erste Gruppe

---

Praktische Muster: Validierung

E-Mail-Adresse

// Grundmuster
const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;

// Test
emailRegex.test('user@example.com');  // true
emailRegex.test('invalid-email');      // false

Musteranalyse:

^                     - Anfang
[a-zA-Z0-9._%+-]+     - Lokaler Teil (1+ Zeichen)
@                     - @-Symbol
[a-zA-Z0-9.-]+        - Domain (1+ Zeichen)
\.                    - . (escaped)
[a-zA-Z]{2,}          - TLD (2+ Zeichen)
$                     - Ende

URL

const urlRegex = /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)*\/?$/;

// Test
urlRegex.test('https://example.com');           // true
urlRegex.test('https://sub.example.com/path');  // true
urlRegex.test('invalid url');                   // false

Telefonnummer (Deutschland)

// Deutsche Mobilnummer
const mobileRegex = /^(\+49|0)1[5-7]\d{8,9}$/;

// Test
mobileRegex.test('+491511234567');  // true
mobileRegex.test('01511234567');     // true

Passworstaerke

// Mindestens 8 Zeichen, Gross-/Kleinbuchstaben, Zahl, Sonderzeichen
const strongPassword = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;

// Musteranalyse
// (?=.*[a-z])   - Mindestens 1 Kleinbuchstabe (Lookahead)
// (?=.*[A-Z])   - Mindestens 1 Grossbuchstabe
// (?=.*\d)      - Mindestens 1 Ziffer
// (?=.*[@$!%*?&]) - Mindestens 1 Sonderzeichen
// {8,}          - 8 oder mehr Zeichen

Kreditkartennummer

// Visa
const visaRegex = /^4[0-9]{12}(?:[0-9]{3})?$/;

// MasterCard
const mastercardRegex = /^5[1-5][0-9]{14}$/;

// Alle Karten (mit optionalen Bindestrichen)
const cardRegex = /^\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}$/;

---

Praktische Muster: Textextraktion

HTML-Tag-Inhaltsextraktion

const html = '<div class="title">Hello World</div>';

// Tag-Inhalt extrahieren
const contentRegex = /<div[^>]*>(.*?)<\/div>/;
const match = html.match(contentRegex);
console.log(match[1]); // "Hello World"

// Alle Tags entfernen
const noTags = html.replace(/<[^>]*>/g, '');
console.log(noTags); // "Hello World"

Domain aus URL extrahieren

const url = 'https://www.example.com/path/page.html';

const domainRegex = /^(?:https?:\/\/)?(?:www\.)?([^/]+)/;
const domain = url.match(domainRegex)[1];
console.log(domain); // "example.com"

Log-Datei-Parsing

const logLine = '[2026-02-21 14:30:45] ERROR: Connection timeout at module.js:42';

const logRegex = /\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\] (\w+): (.+) at (.+):(\d+)/;

const [, datetime, level, message, file, line] = logLine.match(logRegex);

console.log({
  datetime,  // "2026-02-21 14:30:45"
  level,     // "ERROR"
  message,   // "Connection timeout"
  file,      // "module.js"
  line,      // "42"
});

CSV-Parsing (Kommagetrennt)

const csvLine = 'John,"Doe, Jr.",30,"New York, NY"';

// Nach Komma aufteilen (Kommas in Anfuehrungszeichen ignorieren)
const csvRegex = /(?:^|,)("(?:[^"]*(?:""[^"]*)*)"|[^,]*)/g;

const fields = [];
let match;
while ((match = csvRegex.exec(csvLine)) !== null) {
  fields.push(match[1].replace(/^"|"$/g, '').replace(/""/g, '"'));
}

console.log(fields); // ["John", "Doe, Jr.", "30", "New York, NY"]

---

Praktische Muster: Suchen und Ersetzen

Telefonnummer-Formatierung

const phone = '01511234567';

// Leerzeichen hinzufuegen
const formatted = phone.replace(/(\d{4})(\d{3})(\d{4})/, '$1 $2 $3');
console.log(formatted); // "0151 123 4567"

Zahlenformatierung

const amount = '1234567890';

// Tausendertrennzeichen
const formatted = amount.replace(/\B(?=(\d{3})+(?!\d))/g, '.');
console.log(formatted); // "1.234.567.890"

Maskierung

// E-Mail maskieren
const email = 'username@example.com';
const masked = email.replace(/(.{2})(.*)(@.*)/, '$1***$3');
console.log(masked); // "us***@example.com"

// Telefonnummer maskieren
const phone = '0151-123-4567';
const maskedPhone = phone.replace(/(\d{4})-(\d{3})-(\d{4})/, '$1-***-$3');
console.log(maskedPhone); // "0151-***-4567"

Whitespace-Bereinigung

const text = '  Hello    World  ';

// Fuehrende/nachfolgende Whitespaces entfernen
const trimmed = text.replace(/^\s+|\s+$/g, '');

// Mehrere Leerzeichen zu einem normalisieren
const normalized = text.replace(/\s+/g, ' ').trim();
console.log(normalized); // "Hello World"

---

Erweiterte Funktionen

Lookahead

// Positiver Lookahead: (?=...)
// "foo" nur matchen, wenn gefolgt von "bar"
const regex = /foo(?=bar)/;
'foobar'.match(regex);  // ["foo"]
'foobaz'.match(regex);  // null

// Negativer Lookahead: (?!...)
// "foo" nur matchen, wenn NICHT gefolgt von "bar"
const regex2 = /foo(?!bar)/;
'foobaz'.match(regex2); // ["foo"]
'foobar'.match(regex2); // null

Lookbehind

// Positiver Lookbehind: (?<=...)
// Zahlen, denen "$" vorausgeht
const priceRegex = /(?<=\$)\d+/g;
'$100 and $200'.match(priceRegex); // ["100", "200"]

// Negativer Lookbehind: (?<!...)
// Zahlen, denen NICHT "$" vorausgeht
const nonPriceRegex = /(?<!\$)\d+/g;
'$100 and 200'.match(nonPriceRegex); // ["200"]

Benannte Gruppen

const dateRegex = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
const match = '2026-02-21'.match(dateRegex);

console.log(match.groups.year);  // "2026"
console.log(match.groups.month); // "02"
console.log(match.groups.day);   // "21"

Non-Greedy

const html = '<div>Hello</div><div>World</div>';

// Greedy (Standard): So viel wie moeglich matchen
/<div>.*<\/div>/.exec(html)[0];
// "<div>Hello</div><div>World</div>"

// Non-Greedy: So wenig wie moeglich matchen
/<div>.*?<\/div>/.exec(html)[0];
// "<div>Hello</div>"

---

Sprachspezifische Implementierung

JavaScript

// Erstellungsmethoden
const regex1 = /pattern/flags;
const regex2 = new RegExp('pattern', 'flags');

// Methoden
regex.test(str);        // boolean
str.match(regex);       // Array oder null
str.replace(regex, replacement);
str.split(regex);
regex.exec(str);        // Detaillierte Match-Info

// Flags
// g: Globale Suche
// i: Gross-/Kleinschreibung ignorieren
// m: Mehrzeilig
// s: dotAll (. matcht Zeilenumbruch)
// u: Unicode

Python

import re

# Kompilieren
pattern = re.compile(r'pattern', re.IGNORECASE)

# Methoden
re.match(pattern, string)   # Match vom Anfang
re.search(pattern, string)  # Gesamten String durchsuchen
re.findall(pattern, string) # Liste aller Matches
re.sub(pattern, repl, string) # Ersetzen

# Beispiel
emails = re.findall(r'[\w.+-]+@[\w.-]+\.\w+', text)
cleaned = re.sub(r'\s+', ' ', text).strip()

Go

import "regexp"

// Kompilieren
re := regexp.MustCompile(`\d+`)

// Methoden
re.MatchString(s)          // bool
re.FindString(s)           // Erster Match
re.FindAllString(s, -1)    // Alle Matches
re.ReplaceAllString(s, r)  // Ersetzen

// Beispiel
numbers := re.FindAllString("a1b2c3", -1)
// ["1", "2", "3"]

---

Leistungsoptimierung

Kompilierte Regex wiederverwenden

// Langsam: Jedes Mal kompilieren
function validate(email) {
  return /^[\w.+-]+@[\w.-]+\.\w+$/.test(email);
}

// Schnell: Einmal kompilieren
const emailRegex = /^[\w.+-]+@[\w.-]+\.\w+$/;
function validate(email) {
  return emailRegex.test(email);
}

Nicht-erfassende Gruppen verwenden

// Unnoetige Erfassung
const regex = /(https?):\/\/(www\.)?(.+)/;

// Nicht-erfassend fuer unbenoetigte Gruppen
const regex = /(?:https?):\/\/(?:www\.)?(.+)/;

Katastrophales Backtracking vermeiden

// Gefaehrlich: (a+)+ Muster
const bad = /^(a+)+$/;
'aaaaaaaaaaaaaaaaaaaaaa!'.match(bad); // Sehr langsam

// Sicher: Muster umstrukturieren
const good = /^a+$/;

---

Debugging-Tipps

Regex Tester verwenden

1. Muster eingeben
2. Teststring eingeben
3. Hervorgehobene Matches sehen
4. Erfassungsgruppen ueberpruefen

Schrittweise Validierung

// Komplexe Muster schrittweise validieren
const parts = [
  '^',                    // Anfang
  '[a-zA-Z0-9._%+-]+',    // Lokaler Teil
  '@',                    // @
  '[a-zA-Z0-9.-]+',       // Domain
  '\\.',                  // .
  '[a-zA-Z]{2,}',         // TLD
  '$',                    // Ende
];

const emailRegex = new RegExp(parts.join(''));

---

Haeufig gestellte Fragen

F1: Was ist der Unterschied zwischen . und \.?

A: . matcht jedes Zeichen (Wildcard), \. matcht einen literalen Punkt.

F2: Was ist der Unterschied zwischen * und +?

A: * matcht 0 oder mehr, + matcht 1 oder mehr.

• ab*c -> "ac", "abc", "abbc"
• ab+c -> "abc", "abbc" ("ac" matcht nicht)

F3: Wie ignoriere ich Gross-/Kleinschreibung?

A: Verwenden Sie das i-Flag.

• JavaScript: /pattern/i
• Python: re.IGNORECASE

F4: Wie lasse ich . auch Zeilenumbrueche matchen?

A: Verwenden Sie das s-Flag (dotAll).

• JavaScript: /pattern/s
• Python: re.DOTALL

F5: Welche Zeichen muessen escaped werden?

A: \ ^ $ . | ? * + ( ) [ ] { } - diese mit \ escapen.

---

Fazit

Regex-Grundlagen:

1. Grundlegende Syntax: ., *, +, ?, [], ()
2. Metazeichen: \d, \w, \s, ^, $
3. Quantifizierer: {n}, {n,}, {n,m}
4. Erweiterte Funktionen: Lookahead, Lookbehind, Benannte Gruppen

Uebung ist der Schluessel. Testen Sie in Echtzeit im Regex Tester.

---

Verwandte Tools