Regex ist der Moment, in dem aus „ich suche mal eben“ plötzlich „warum matcht das die halbe Festplatte?“ wird. Wir haben uns das Biest im Selbstversuch geschnappt: reguläre Ausdrücke sauber verstehen, testen und dann erst auf Logs, Configs und Skripte loslassen. Wie ein Sysadmin mit Helm. Nicht wie ein Praktikant mit `rm -rf`.
Der wichtigste Trick: Regex ist keine Magie, sondern Musterbeschreibung. Du sagst nicht „finde irgendwie eine IP“, sondern definierst exakt, wie eine IP aussehen darf. Beispiel:
```bash
grep -E '([0-9]{1,3}\.){3}[0-9]{1,3}' access.log
```
Das findet IPv4-artige Muster. Nicht perfekt validiert, aber für Logsuche meistens gut genug. `-E` aktiviert Extended Regex, damit du nicht jedes `{}` und `()` mit Backslashes dekorieren musst wie einen Weihnachtsbaum.
Ein paar Basics, die du wirklich im Muskelgedächtnis haben willst:
```text
. beliebiges Zeichen
* 0 bis n Wiederholungen
+ 1 bis n Wiederholungen
? optional
^ Zeilenanfang
$ Zeilenende
[abc] a oder b oder c
[^abc] nicht a, b oder c
{3} genau 3 Wiederholungen
{1,3} 1 bis 3 Wiederholungen
```
Wenn du in Logs nach HTTP-Fehlern suchst:
```bash
grep -E 'HTTP/[0-9.]+" 5[0-9]{2}' access.log
```
Das matcht Statuscodes von 500 bis 599. Schön. Sauber. Kein Kaffeesatz.
Vor dem Einsatz auf echten Dateien testen wir Muster immer klein. Entweder mit `echo`, Testdateien oder Tools wie `grep` selbst:
```bash
printf "error\nwarning\nERROR\n" | grep -Ei 'error|warning'
```
`-i` ignoriert Groß-/Kleinschreibung. `-n` zeigt Zeilennummern. `-o` zeigt nur den Treffer:
```bash
grep -Eno 'user=[a-zA-Z0-9._-]+' app.log
```
Sehr praktisch, wenn du aus Müll nur die verwertbaren Bits ziehen willst.
Mit `sed` wird Regex dann zum Schweizer Taschenmesser. Beispiel: E-Mail-Adressen in einer Datei maskieren:
```bash
sed -E 's/[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/[REDACTED]/g' users.txt
```
Wichtig: Erst ohne `-i` testen. Immer. Wirklich immer. `sed -i` schreibt direkt in die Datei. Das ist wie Laserschwert ohne Schutzbrille.
Wenn es komplexer wird, packen wir Regex in Skripte. In Bash zum Beispiel:
```bash
!/usr/bin/env bash
line="backup-2025-01-31.tar.gz"
if [[ "$line" =~ ^backup-[0-9]{4}-[0-9]{2}-[0-9]{2}\.tar\.gz$ ]]; then
echo "Backup-Datei sieht gut aus."
else
echo "Verdächtiger Dateiname."
fi
```
Achte auf Anchors: `^` und `$` verhindern Teiltreffer. Ohne die würde auch `evil-backup-2025-01-31.tar.gz.exe` fröhlich durchwinken. Und das will niemand, außer vielleicht Malware mit Humor.
Unser Regex-Debugging läuft meistens so:
1. Beispielzeilen sammeln: gute und schlechte.
2. Kleines Muster bauen.
3. Mit `grep -E` testen.
4. Schrittweise erweitern.
5. Anchors setzen.
6. Erst dann in `sed`, Cronjobs oder Skripte einbauen.
Regex soll nicht clever aussehen. Regex soll wartbar sein. Wenn du dein eigenes Muster nach zwei Wochen nicht mehr verstehst, war es kein Geniestreich, sondern ein Minenfeld mit Sonderzeichen.
Unser Fazit aus dem Maschinenraum: Lieber drei einfache Regexe als ein Monster mit 14 Gruppen, das nur bei Vollmond funktioniert. Muster finden statt raten. Und vor `sed -i` immer einmal tief durchatmen.