Reguläre Ausdrücke — Textmuster finden mit grep und sed

Reguläre Ausdrücke — kurz Regex — sind Suchmuster, mit denen du Text gezielt durchsuchen, filtern und umformen kannst. Sie funktionieren in grep, sed, awk, find und fast jedem Texteditor. Wer Regex beherrscht, kann Logdateien in Sekunden durchsuchen, Konfigurationen skriptgesteuert ändern und Datentransformationen automatisieren, die sonst manuell Stunden dauern würden. Dieser Artikel baut die Grundbausteine schrittweise auf und zeigt, wie du grep und sed damit in der Praxis einsetzt.

Was sind reguläre Ausdrücke?

Ein regulärer Ausdruck ist ein Muster, das beschreibt, wie eine Zeichenkette aussehen soll — nicht was sie exakt ist. Statt nach dem festen String fehler zu suchen, kannst du nach allem suchen, das mit f beginnt, vier beliebige Zeichen enthält und auf r endet: f.{4}r. Das Muster trifft auf fehler, filter und fahrer — aber nicht auf fur, das nur ein Zeichen zwischen f und r hat.

Regex ist keine Bash-Erfindung: Das Konzept stammt aus der Theoretischen Informatik (Stephen Kleene, 1951), wurde in Unix-Tools wie ed und grep (1973) populär und ist heute Standard in Python, JavaScript, Java, PHP und praktisch jeder Programmiersprache. Wer Regex einmal wirklich verstanden hat, setzt dieses Wissen überall ein — nicht nur im Terminal.

Zwei Dialekte sind unter Linux relevant:

• BRE (Basic Regular Expressions): Standard bei grep ohne Flags und bei sed ohne -E. Quantifikatoren wie + und ? müssen mit Backslash escaped werden: +, ?. Gruppen ebenfalls: (...). Das macht BRE-Muster bei komplexeren Ausdrücken schwer lesbar.
• ERE (Extended Regular Expressions): Aktiviert mit grep -E (oder egrep) und sed -E. +, ?, () und | funktionieren direkt ohne Backslash. ERE ist lesbarer und weniger fehleranfällig — verwende ihn immer, wenn du die Wahl hast.

Grundbausteine: Die Elemente jedes Musters

Regex besteht aus wenigen primitiven Elementen, die sich zu beliebig komplexen Mustern kombinieren lassen. Drei Fakten vorab: Regex ist standardmäßig case-sensitive; ein Muster ohne Anker trifft auf jede Zeile, die es enthält; und Quantifikatoren sind gierig — sie greifen so viel wie möglich.

Literale — Zeichen, die exakt sich selbst bedeuten:

# Das Wort "bash" in einer Datei finden:
$ grep 'bash' /etc/shells
/bin/bash
/usr/bin/bash

# Sonderzeichen müssen escaped werden, damit sie literal gelten:
# . * ^ $ [ ]  + ? | ( ) { } brauchen einen Backslash davor:
$ echo '3.14' | grep '3.14'   # nur der Punkt, nicht "3x14"
3.14

Punkt . — steht für genau ein beliebiges Zeichen (außer Zeilenumbruch):

# b, dann ein beliebiges Zeichen, dann sh:
$ echo -e 'bashnbushnbuch' | grep 'b.sh'
bash
bush

# Punkt muss escaped werden, um einen literalen Punkt zu bedeuten:
$ echo -e '192.168.1.1n192X168Y1Z1' | grep '192.168'
192.168.1.1

Stern * — das vorangehende Element null- oder mehrfach (auch null!):

# ba gefolgt von beliebig vielen a:
$ echo -e 'bnbanbaanbaaa' | grep 'ba*'
b
ba
baa
baaa

# Achtung: * bedeutet "null oder mehr" -- auch b ohne a trifft 'ba*',
# weil * null Wiederholungen von a erlaubt.

# .* ist das häufigste Muster: beliebig viele beliebige Zeichen:
$ grep 'server.*port' config.conf   # "server" gefolgt von beliebigem Text und "port"

Anker ^ und $ — Zeilenanfang und Zeilenende:

# Nur Zeilen, die mit "Error" beginnen:
$ grep '^Error' /var/log/syslog

# Nur Zeilen, die mit einem Semikolon enden:
$ grep ';$' config.conf

# Leerzeilen finden (Anfang direkt gefolgt von Ende):
$ grep '^$' datei.txt

# Zeilen, die NUR Leerzeichen oder Tabs enthalten (oder leer sind):
$ grep '^[[:space:]]*$' datei.txt

# Zeilen, die exakt und nur "ja" enthalten:
$ grep '^ja$' antworten.txt

Zeichenklassen [...] — eine Menge möglicher Zeichen an einer Position:

# Vokale finden (-o gibt nur den gematchten Teil aus):
$ echo 'Hallo Welt' | grep -o '[aeiouAEIOU]'
a
o
e

# Ziffern 0-9 (Kurzschreibweise mit Bindestrich):
$ grep '[0-9]' datei.txt

# POSIX-Klassen -- portabler als Hardcoding, berücksichtigen Locale:
# [[:alpha:]]  = Buchstaben
# [[:digit:]]  = Ziffern (0-9)
# [[:alnum:]]  = Buchstaben und Ziffern
# [[:space:]]  = Leerzeichen, Tab, Zeilenumbruch
# [[:upper:]]  = Großbuchstaben
# [[:lower:]]  = Kleinbuchstaben
# [[:punct:]]  = Satzzeichen
$ grep '[[:digit:]]' datei.txt       # alle Zeilen mit Ziffern
$ grep '^[[:upper:]]' datei.txt      # Zeilen, die mit Großbuchstaben beginnen

Negierte Zeichenklassen [^...] — alles außer den genannten Zeichen:

# Zeilen ausgeben, die nicht mit # beginnen:
$ grep '^[^#]' /etc/ssh/sshd_config

# Zeilen, die ausschließlich aus Nicht-Ziffern bestehen:
$ grep '^[^0-9]*$' datei.txt

# Zeichenklasse mit Bindestrich am Anfang oder Ende (nicht als Bereich):
$ grep '[-+]' datei.txt    # findet Zeilen mit - oder +

Erweiterte Regex (ERE): Quantifikatoren, Gruppen und Alternativen

ERE erweitert die Grundbausteine um Quantifikatoren, die präzisere Mengenangaben erlauben, sowie Gruppen und Alternativen. Alle folgenden Beispiele nutzen grep -E oder sed -E. Du merkst sofort den Unterschied: Kein Backslash vor +, ? oder ().

Quantifikatoren im Überblick:

# + -- ein oder mehr (mindestens einmal, kein Treffer bei Null):
$ echo -e 'bnbanbaa' | grep -E 'ba+'
ba
baa
# 'b' allein trifft nicht -- ba+ verlangt mindestens ein a.

# ? -- null oder einmal (macht das vorangehende Element optional):
$ echo -e 'colourncolorncollor' | grep -E 'colou?r'
colour
color
# 'collor' trifft nicht -- das o nach coll ist nicht u.

# {n} -- genau n-mal:
$ grep -E '[0-9]{4}' datei.txt       # genau 4 aufeinander folgende Ziffern

# {n,m} -- n bis m-mal (n <= Treffer <= m):
$ grep -E '[0-9]{2,4}' datei.txt     # 2 bis 4 Ziffern

# {n,} -- mindestens n-mal:
$ grep -E '[a-z]{8,}' datei.txt      # Wörter mit mindestens 8 Kleinbuchstaben

# {0,1} ist äquivalent zu ?:
$ grep -E 'colou{0,1}r' datei.txt    # gleich wie colou?r

Gruppen () und Alternativen |:

# Gruppe: Quantifikator auf mehrere Zeichen anwenden:
$ echo -e 'hahanhanhahaha' | grep -E '(ha)+'
haha
ha
hahaha

# Alternative: entweder "fehler" oder "warning" oder "critical":
$ grep -iE 'fehler|warning|critical' /var/log/syslog

# Alternative innerhalb einer Gruppe (z.B. Dateiendungen):
$ grep -E '.(jpg|png|gif|webp)$' dateiliste.txt

# Gruppe mit nachfolgendem Quantifikator:
$ grep -E '(ab){3}' datei.txt        # ababab

Wortgrenze b:

# "bash" als ganzes Wort -- trifft nicht auf "unbashable":
$ echo -e 'bash ist coolnunbashablenbash!' | grep -E 'bbashb'
bash ist cool
bash!

# grep -w ist kürzer und macht das gleiche wie b...b:
$ grep -w 'bash' /etc/shells
/bin/bash

# Wortgrenze am Anfang -- nur Wörter, die mit "log" beginnen:
$ grep -E 'blog[a-z]*' datei.txt   # trifft: log, logger, logging ...

grep im Detail: Flags und Praxisbeispiele

grep (Global Regular Expression Print) durchsucht Eingaben zeilenweise und gibt Zeilen aus, auf die das Muster passt. Es liest aus Dateien oder der Standardeingabe (Pipe). Das Tool existiert seit 1973 und ist auf jedem Linux-System vorhanden — es gibt keine Situation, in der du in einem Terminal auf grep verzichten müsstest.

Die wichtigsten Flags mit konkreten Anwendungsfällen:

# -i  Groß-/Kleinschreibung ignorieren:
$ grep -i 'error' /var/log/syslog
# trifft auf: Error, ERROR, error, eRrOr

# -v  Invertieren -- Zeilen ausgeben, die NICHT passen:
$ grep -v '^#' /etc/ssh/sshd_config
# Alle Nicht-Kommentarzeilen der SSH-Konfiguration

# -c  Nur Anzahl der Treffer-Zeilen zählen:
$ grep -c 'FAILED' /var/log/auth.log
17

# -n  Zeilennummer vor jeder Ausgabe:
$ grep -n 'PermitRootLogin' /etc/ssh/sshd_config
34:#PermitRootLogin prohibit-password
84:PermitRootLogin no

# -l  Nur Dateinamen ausgeben, die Treffer enthalten:
$ grep -rl 'passwort' /home/gunter/
/home/gunter/.bashrc
/home/gunter/notizen.txt

# -r  Rekursiv in Verzeichnissen suchen:
$ grep -r 'TODO' /home/gunter/scripts/

# -w  Nur ganze Wörter (wie b...b um das Muster):
$ grep -w 'bash' /etc/shells
/bin/bash

# -o  Nur den gematchten Teil ausgeben -- sehr nützlich zum Extrahieren:
$ grep -oE '[0-9]+' datei.txt   # alle Zahlenfolgen aus der Datei

# --color  Treffer farbig hervorheben:
$ grep --color 'error' /var/log/syslog

# Flags kombinieren -- z.B. rekursiv, Zeilennummern, Dateinamen, color:
$ grep -rn --color 'PermitRootLogin yes' /etc/

Praxisbeispiel: Logfile-Analyse

# Alle SSH-Fehlversuche der letzten Einträge aus auth.log:
$ grep 'Failed password' /var/log/auth.log | tail -20

# IP-Adressen extrahieren, sortieren, häufigste zuerst:
$ grep 'Failed password' /var/log/auth.log 
  | grep -oE '[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}' 
  | sort | uniq -c | sort -rn | head -10
    143 185.220.101.47
     82 45.33.32.156
     61 194.165.16.37

# Zeilen mit "error" oder "warning" aus einem Service-Log:
$ grep -iE 'error|warning|critical' /var/log/syslog | grep 'NetworkManager'

# Nur Zeilen in einem Zeitfenster (Apr 23, zwischen 09:00 und 09:30):
$ grep 'Apr 23 09:[012][0-9]' /var/log/syslog

Praxisbeispiel: Prozesse und Konfigurationsdateien:

# Laufende Python-Prozesse finden (grep selbst herausfiltern):
$ ps aux | grep -v grep | grep python

# Alle gesetzten SSH-Optionen (keine Kommentare, keine Leerzeilen):
$ grep -vE '^[[:space:]]*(#|$)' /etc/ssh/sshd_config

# In allen .sh-Dateien nach "set -e" suchen:
$ grep -r --include='*.sh' 'set -e' /home/gunter/scripts/

# Dateien finden, die eine bestimmte Funktion definieren:
$ grep -rl 'function backup' /home/gunter/

# grep -A und -B: Kontext vor/nach dem Treffer ausgeben:
$ grep -A 3 'failed' /var/log/syslog     # 3 Zeilen NACH dem Treffer
$ grep -B 2 'Segfault' /var/log/kern.log  # 2 Zeilen VOR dem Treffer
$ grep -C 2 'error' log.txt               # 2 Zeilen vor UND nach

sed Grundlagen: Suchen, Ersetzen, Löschen

sed (Stream Editor) liest Text zeilenweise, wendet Kommandos an und gibt das Ergebnis auf der Standardausgabe aus. Die Originaldatei bleibt unverändert, außer du nutzt -i. sed ist seit 1973 Teil von Unix — nahezu identisch auf allen Linux-Distros, macOS und BSD. Das häufigste Kommando ist das Substitutionskommando s:

# Grundstruktur: s/Suchmuster/Ersatz/Flags
$ echo 'Hallo Welt' | sed 's/Welt/Linux/'
Hallo Linux

# Ohne Flag: nur die erste Fundstelle pro Zeile:
$ echo 'aaa bbb aaa' | sed 's/aaa/XXX/'
XXX bbb aaa

# Flag g (global): alle Vorkommen in jeder Zeile:
$ echo 'aaa bbb aaa' | sed 's/aaa/XXX/g'
XXX bbb XXX

# Flag i (case-insensitive, GNU sed):
$ echo 'Fehler FEHLER fehler' | sed 's/fehler/OK/gi'
OK OK OK

# Trennzeichen muss nicht / sein -- nützlich bei Pfaden:
$ sed 's|/usr/local/bin|/opt/bin|g' config.conf
# Beliebiges Zeichen als Trennzeichen: |, #, @, !, % etc.

Gruppen und Rückverweise im Ersatztext:

# Gruppe erfassen mit () in ERE (sed -E):
# Vorname Nachname zu Nachname, Vorname:
$ echo 'Gunter Herdrich' | sed -E 's/([A-Za-z]+) ([A-Za-z]+)/2, 1/'
Herdrich, Gunter

# Datum von YYYY-MM-DD auf DD.MM.YYYY umformatieren:
$ echo '2026-04-23' | sed -E 's/([0-9]{4})-([0-9]{2})-([0-9]{2})/3.2.1/'
23.04.2026

# & steht für den gesamten gematchten Text:
$ echo 'bash' | sed 's/bash/[&]/'   # & = bash
[bash]

In-place Bearbeitung mit -i:

# Direkt in der Datei ersetzen (kein Backup!):
$ sed -i 's/localhost/127.0.0.1/g' /etc/myapp/config.conf

# Mit Backup-Suffix -- sed erstellt config.conf.bak:
$ sed -i.bak 's/localhost/127.0.0.1/g' /etc/myapp/config.conf

Adressierung — nur bestimmte Zeilen bearbeiten:

# Nur Zeile 5 bearbeiten:
$ sed '5s/alt/neu/' datei.txt

# Zeilen 10 bis 20 bearbeiten:
$ sed '10,20s/alt/neu/g' datei.txt

# Alle Zeilen, auf die ein Muster passt:
$ sed '/^#/s/old/new/' datei.txt     # Zeilen, die mit # beginnen

# Zeilen löschen -- Kommando d:
$ sed '/^#/d' config.conf            # alle Kommentarzeilen löschen
$ sed '/^$/d' datei.txt              # alle Leerzeilen löschen

# Kommentare UND Leerzeilen in einem Durchgang:
$ sed -E '/^[[:space:]]*(#|$)/d' config.conf

# Zeilen von Muster A bis Muster B löschen (inklusive):
$ sed '/START/,/END/d' datei.txt

Flag p mit -n — nur Treffer ausgeben:

# -n unterdrückt die normale Ausgabe; p gibt die Zeile explizit aus:
$ sed -n '/error/p' /var/log/syslog
# Funktional ähnlich wie: grep 'error' /var/log/syslog

# Der Vorteil von sed: weitere Kommandos in derselben Pipe anwenden.
# Zum Beispiel: Zeilen mit error finden UND dort etwas ersetzen:
$ sed -n '/error/{s/WARN/ERROR/gp}' log.txt

Praxisbeispiele für den Alltag:

# Port in sshd_config von 22 auf 2222 ändern:
$ sed -i.bak 's/^Port 22$/Port 2222/' /etc/ssh/sshd_config

# Semikolon-Trennzeichen in einer CSV durch Kommas ersetzen:
$ sed 's/;/,/g' eingabe.csv > ausgabe.csv

# Windows-Zeilenenden (CRLF) in Unix-Zeilenenden (LF) konvertieren:
$ sed 's/r//' datei.txt > datei_unix.txt

# E-Mail-Adressen anonymisieren:
$ sed -E 's/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}/[REDACTED]/g' datei.txt

# Ersten Buchstaben jedes Wortes großschreiben (GNU sed, u):
$ echo 'hallo welt' | sed 's/b./u&/g'
Hallo Welt

Häufige Regex-Muster als Referenz

Diese Muster deckst du im Linux-Alltag täglich ab — als ERE-Syntax, direkt einsetzbar mit grep -E oder sed -E. Wichtig: Die Muster für E-Mail und IP-Adresse sind vereinfacht und fangen die meisten Praxisfälle ab — eine vollständige RFC-konforme Validierung wäre deutlich komplexer und ist in den meisten Fällen nicht nötig.

# IP-Adressen aus einer Logdatei extrahieren und deduplizieren:
$ grep -oE '[0-9]{1,3}(.[0-9]{1,3}){3}' /var/log/auth.log | sort -u

# Alle E-Mail-Adressen im Verzeichnis finden:
$ grep -rhoE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}' /etc/ 2>/dev/null | sort -u

# Alle Leerzeilen entfernen:
$ grep -v '^$' datei.txt > bereinigt.txt

# Alle Kommentarzeilen entfernen:
$ grep -vE '^[[:space:]]*#' config.conf

Regex debuggen: Schritt für Schritt zum richtigen Muster

Regex-Fehler entstehen meistens durch unbeabsichtigte Treffer (Muster zu breit) oder fehlende Treffer (Muster zu eng). Die effizienteste Debuggingstrategie: Muster schrittweise aufbauen, bei jedem Schritt sofort testen. Dafür reicht das Terminal — du brauchst kein externes Tool. Der Schlüssel: grep -o zeigt dir exakt, was das Muster trifft, nicht nur welche Zeile.

Schritt-für-Schritt-Aufbau am Beispiel Datum YYYY-MM-DD:

# Schritt 1: Überhaupt Ziffern finden:
$ echo '2026-04-23 ist heute' | grep -oE '[0-9]+'
2026
04
23

# Schritt 2: Vierstellige Jahreszahl isolieren:
$ echo '2026-04-23 ist heute' | grep -oE '[0-9]{4}'
2026

# Schritt 3: Ganzes Datum YYYY-MM-DD:
$ echo '2026-04-23 ist heute' | grep -oE '[0-9]{4}-[0-9]{2}-[0-9]{2}'
2026-04-23

# Schritt 4: Sicherstellen, dass es kein Datum in einer längeren Zahl ist:
$ printf '2026-04-23n12026-04-23n' | grep -oE 'b[0-9]{4}-[0-9]{2}-[0-9]{2}b'
2026-04-23
# (12026-04-23 trifft nicht -- korrekt)

Häufige Fehlerquellen und ihre Lösung:

# Fehler 1: Punkt nicht escaped -- trifft zu breit:
$ printf '192.168.1.1n192X168Y1Z1n' | grep '192.168.1.1'
192.168.1.1
192X168Y1Z1    # unerwünschter Treffer!

# Lösung: Punkt escapen:
$ printf '192.168.1.1n192X168Y1Z1n' | grep '192.168.1.1'
192.168.1.1

# Fehler 2: Doppelte Anführungszeichen -- Shell interpretiert Backslashes:
$ echo 'test' | grep "btestb"    # b wird von der Shell verändert

# Lösung: Immer einfache Anführungszeichen für Regex-Muster:
$ echo 'test' | grep -E 'btestb'
test

# Fehler 3: .* greift gierig bis zum letzten möglichen Treffer:
$ echo '<a href="url">Text</a>' | grep -oE '<.*>'
<a href="url">Text</a>    # zu viel -- bis zum letzten >

# Lösung: Negierte Zeichenklasse statt .*:
$ echo '<a href="url">Text</a>' | grep -oE '<[^>]+>'
<a href="url">
</a>

sed-spezifisches Debugging — immer erst ohne -i testen:

# Muster testen -- Ausgabe in Terminal, nicht in Datei:
$ sed 's/Port 22/Port 2222/' /etc/ssh/sshd_config | grep -n 'Port'
34:Port 2222

# Wenn das korrekt aussieht, dann in-place mit Backup:
$ sed -i.bak 's/^Port 22$/Port 2222/' /etc/ssh/sshd_config

# Unterschied zur Originaldatei prüfen:
$ diff /etc/ssh/sshd_config /etc/ssh/sshd_config.bak

Weiterlernen

Du kennst jetzt die Grundbausteine und ERE-Erweiterungen, kannst grep und sed produktiv einsetzen und Muster schrittweise debuggen. Das reicht für die meisten Alltagsaufgaben — Logfiles analysieren, Configs anpassen, Daten extrahieren und transformieren. Als nächsten Schritt lohnt sich ein Blick auf awk, das Regex mit echten Berechnungen und Feldzugriff kombiniert.

Drei Themen, die direkt anknüpfen:

• Reguläre Ausdrücke in Bash-Scripts einsetzen — Variablen prüfen, Ausgaben filtern, Ergebnisse weiterverarbeiten mit [[ =~ ]]: Shellscripts schreiben
• grep und sed werden in Kombination mit Pipes besonders mächtig — wie Redirect, Pipes und Wildcards zusammenspielen: Komfortfunktionen in der Bash
• Die übrigen Kommandos, die du in Kombination mit grep und sed brauchst — sort, uniq, cut, wc: Grundlegende Kommandos