grep, sed, awk – Regex auf der Kommandozeile

Reguläre Ausdrücke entstanden zusammen mit Unix in den 1970ern – und nirgends sind sie so tief integriert wie in der Unix-Welt. Auf der Linux-Shell hast du drei klassische Werkzeuge die Regex zur Lebensgrundlage haben: grep (suchen), sed (ersetzen) und awk (Spalten verarbeiten). Wer Server administriert, Logs auswertet oder einfach große Textmengen filtert, kommt um diese Drei nicht herum.

Du kannst sie alle auch unter Windows nutzen: in WSL, in Git Bash, oder als Portierungen. PowerShell hat eigene Pendants (Select-String, -replace) die das gleiche tun. Diese Lektion zeigt die Unix-Klassiker und ihre Stärken.

1) Die drei Werkzeuge im Überblick

Jedes der drei Tools hat eine klare Spezialisierung. Wenn du verstehst was jedes kann – und was nicht – wählst du leicht das richtige für deine Aufgabe:

grep, sed, awk – wer macht was?

grep

Global Regular Expression Print

+ Zeilen finden die zu Pattern passen

– Verändert nichts, gibt nur aus

Du suchst in einer oder vielen Dateien nach Zeilen die ein Pattern enthalten. Wie eine Suche im Texteditor, aber für die Kommandozeile.

sed

Stream EDitor

+ Suchen UND Ersetzen

– Zeilen-orientiert, kein „Lookbehind"

Du willst Text transformieren: Wörter ersetzen, Zeilen löschen, Datumsformate ändern. sed liest stream-weise und schreibt das Ergebnis.

awk

Aho-Weinberger-Kernighan

+ Spalten verarbeiten, Berechnungen

– Eigene Mini-Sprache, Lernkurve

Du hast tabellenähnliche Daten (CSV, Logs mit Spalten) und willst spezifische Spalten extrahieren, summieren, filtern. awk ist Mini-SQL für Textdateien.

Faustregel: grep = „zeig mir Zeilen mit X". sed = „ersetze X durch Y". awk = „nimm Spalte 3 wo Spalte 1 = X ist". In der Praxis kombinierst du sie oft mit Pipes: cat log.txt | grep ERROR | awk '{print $3}'.

2) grep: das schweizer Suchmesser

grep sucht zeilenweise. Wenn das Pattern in einer Zeile matched, wird die Zeile ausgegeben. Sehr einfache, aber enorm nützliche Grundfunktion:

Bash – grep Grundlagen

anna@laptop:~$ grep "ERROR" app.log ERROR: connection refused at 14:30 2026-05-17 14:32 ERROR: timeout DEBUG: retry attempt 1 ERROR: gateway failed anna@laptop:~$ # Nur Anzahl der Treffer: anna@laptop:~$ grep -c "ERROR" app.log 3 anna@laptop:~$ # Mit Zeilennummer: anna@laptop:~$ grep -n "ERROR" app.log 1:ERROR: connection refused at 14:30 3:2026-05-17 14:32 ERROR: timeout 8:ERROR: gateway failed

Die wichtigsten Flags:

Flag	Bedeutung
`-i`	Case-insensitive (ERROR = error = Error)
`-v`	Invert: Zeilen die NICHT matchen
`-n`	Mit Zeilennummer ausgeben
`-c`	Nur Anzahl der Treffer, nicht die Zeilen
`-l`	Nur Dateinamen mit Treffern (statt Zeilen)
`-r` oder `-R`	Rekursiv in Verzeichnissen
`-A 3`	3 Zeilen nach Treffer mitausgeben
`-B 3`	3 Zeilen vor Treffer
`-C 3`	3 Zeilen drumherum (Context)
`-E`	Extended Regex (POSIX ERE)
`-P`	Perl-Compatible Regex (PCRE, mächtiger)
`-w`	Match nur ganze Wörter
`--color`	Treffer farblich hervorheben

Besonders nützlich: -A/-B/-C für Kontext. Bei einer Error-Meldung willst du oft die umliegenden Zeilen sehen um zu verstehen was vorher passierte. Mehr zu Log-Analyse in K46 L7.

3) grep: drei Varianten

Es gibt drei grep-Versionen mit unterschiedlichen Regex-Dialekten:

grep (BRE): Basic Regular Expression. Standard. + und ? müssen escaped werden: \+, \?. Auch Klammern: $...$. Veraltet, aber default.
grep -E (ERE): Extended Regular Expression. Wie aus L2 bekannt. Quantoren ohne Escape, normale Klammern für Gruppen. Empfohlen für moderne Nutzung.
grep -P (PCRE): Perl-Compatible. Volle Mächtigkeit: \d, \w, Lookarounds, Backreferences. Nicht überall verfügbar.

Drei Varianten am gleichen Pattern

# BRE (Standard): + muss escaped werden $ grep "[0-9]\+" data.txt # ERE: kompakter $ grep -E "[0-9]+" data.txt # PCRE: mit \d $ grep -P "\d+" data.txt # egrep = grep -E (kompatibilitätshalber): $ egrep "[0-9]+" data.txt

Faustregel: standardmäßig grep -E nutzen, oder bei komplexen Patterns mit \d/\w direkt grep -P.

4) grep: praktische Beispiele

Klassische grep-Aufgaben aus dem Admin-Alltag:

grep im Alltag

# Alle ERROR-Zeilen aus mehreren Logs: $ grep ERROR /var/log/*.log # Alle E-Mail-Adressen in einer Datei: $ grep -oE "[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}" mails.txt # -o = nur den gematchten Teil ausgeben, nicht die ganze Zeile # Rekursiv in allen .py-Dateien nach TODO suchen: $ grep -rn --include="*.py" "TODO" . # Logs ohne DEBUG-Zeilen anzeigen: $ grep -v "DEBUG" app.log # Wie viele Login-Versuche aus jeder IP? $ grep "Login" auth.log | grep -oE "\d+\.\d+\.\d+\.\d+" | sort | uniq -c

Der letzte Pipe-Befehl ist eine Pipeline-Kombination wie sie oft vorkommt: grep filtern → grep extrahieren mit -o → sort + uniq zum Aggregieren. Solche Pipelines sind das Markenzeichen der Unix-Philosophie: kleine Werkzeuge die zusammen Großes leisten.

5) sed: Stream Editor für Ersetzungen

sed liest Zeile für Zeile, wendet Befehle an, gibt das Ergebnis aus. Der häufigste Befehl ist s/pattern/replacement/flags (substitute):

sed Grundbefehl

$ echo "Hallo Welt" | sed 's/Welt/Erde/' Hallo Erde $ # Mit Datei: $ sed 's/foo/bar/' input.txt # Ersetzt das ERSTE Vorkommen pro Zeile $ # Mit g-Flag: ALLE Vorkommen pro Zeile $ sed 's/foo/bar/g' input.txt $ # Mit -i: direkt in Datei schreiben (in-place) $ sed -i 's/foo/bar/g' input.txt $ # Mit -E für ERE-Syntax (empfohlen): $ sed -E 's/[0-9]+/NUM/g' data.txt

⚠ Achtung: sed -i ändert die Datei!

Das -i-Flag macht in-place editing – die Originaldatei wird überschrieben! Wenn das Pattern falsch ist, sind die Daten weg. Best Practice: zuerst ohne -i testen und das Ergebnis prüfen. Bei wichtigen Daten: sed -i.bak '...' – das macht zusätzlich eine Backup-Datei mit Endung .bak.

6) sed: Gruppen und Backreferences

Die wahre Stärke von sed kommt mit Capturing Groups und Backreferences. Im Standard-sed musst du Gruppen mit $...$ escapen, im ERE-Modus (-E) ohne Backslash. Backreferences sind immer \1, \2, ...:

sed mit Gruppen und Backrefs

# Datum von 17.05.2026 zu 2026-05-17 umformatieren: $ echo "17.05.2026" | sed -E 's/([0-9]{2})\.([0-9]{2})\.([0-9]{4})/\3-\2-\1/' 2026-05-17 # Nachname,Vorname zu "Vorname Nachname": $ echo "Müller,Anna" | sed -E 's/([^,]+),([^,]+)/\2 \1/' Anna Müller # Verdoppel jede Zahl im Text: $ echo "a=5, b=10" | sed -E 's/([0-9]+)/\1\1/g' a=55, b=1010 # Email-Anonymisierung: a***@firma.de $ echo "kontakt: anna@firma.de" | sed -E 's/(\w)\w+@/\1***@/' kontakt: a***@firma.de

Bei der DSGVO-konformen Datenmaskierung – z.B. E-Mails vor Speicherung anonymisieren – ist sed sehr nützlich. Auch beim Aufbereiten von Log-Dateien für externe Auswertung.

7) sed: weitere Befehle

Sed kann mehr als nur substituieren. Weitere häufige Befehle:

sed weiteres

# Zeile 5 anzeigen: $ sed -n '5p' file.txt # -n = nicht alles ausgeben, p = print # Zeilen 10-20: $ sed -n '10,20p' file.txt # Zeile mit ERROR löschen: $ sed '/ERROR/d' app.log # Alle leeren Zeilen entfernen: $ sed '/^$/d' file.txt # Vor jeder Zeile mit "TODO" einen Trennstrich einfügen: $ sed '/TODO/i\\---' file.txt # Nur Zeilen die ein Pattern matchen ersetzen: $ sed '/^WARN/s/old/new/' app.log # Ersetzt "old" → "new" nur in Zeilen die mit WARN beginnen

Mit diesen Befehlen kannst du komplexe Text-Transformationen bauen. Sed-Skripte können beliebig lang werden – aber dafür gibt's heutzutage bessere Werkzeuge (Python, awk). Sed ist optimal für einzeilige Pipeline-Operationen.

8) awk: Mini-SQL für Textdateien

awk ist anders als grep und sed: es ist eine eigene Mini-Programmiersprache. Ideal für Daten in Spalten – Logs, CSV, Konfigurationsdateien. Die Grundsyntax:

awk-Grundsyntax

1awk 'PATTERN { AKTION }' file.txt

Pro Zeile prüft awk das PATTERN – ist es wahr, wird die AKTION ausgeführt. PATTERN kann sein: Regex, Bedingung, leer (immer). AKTION ist meist print .... Spalten werden mit $1, $2, etc. angesprochen, $0 ist die ganze Zeile:

awk Grundlagen

# Eine Beispieldatei: $ cat employees.csv Anna,30,Berlin,4500 Bob,42,Munich,5200 Clara,28,Hamburg,4800 David,55,Berlin,6100 # Alle Namen (Spalte 1) ausgeben: $ awk -F',' '{print $1}' employees.csv Anna Bob Clara David # -F',' = Feldtrenner ist Komma (Default: Whitespace) # Name + Gehalt: $ awk -F',' '{print $1, $4}' employees.csv Anna 4500 Bob 5200 Clara 4800 David 6100 # Nur Berliner Mitarbeiter: $ awk -F',' '$3 == "Berlin" {print $1}' employees.csv Anna David

Spürst du die Mächtigkeit? Mit einem Einzeiler hast du SQL-ähnliche Filter über CSV-Daten. $3 == "Berlin" ist das Pattern, {print $1} die Aktion.

9) awk: Berechnungen

awk kann rechnen – Summen, Durchschnitte, Counts:

awk-Berechnungen

# Summe aller Gehälter: $ awk -F',' '{sum += $4} END {print sum}' employees.csv 20600 # Durchschnitt: $ awk -F',' '{sum += $4; n++} END {print sum/n}' employees.csv 5150 # Mitarbeiter pro Stadt zählen: $ awk -F',' '{count[$3]++} END {for (c in count) print c, count[c]}' employees.csv Berlin 2 Munich 1 Hamburg 1 # Höchstes Gehalt pro Stadt: $ awk -F',' '$4 > max[$3] {max[$3] = $4; name[$3] = $1} END {for (c in max) print c, name[c], max[c]}' employees.csv Berlin David 6100 Munich Bob 5200 Hamburg Clara 4800

Die spezielle END-Sektion läuft nach allen Zeilen. BEGIN läuft vor. Damit baust du Aggregate – Summen, Counts, Durchschnitte. Außerdem hat awk assoziative Arrays wie count[$3] – das ist quasi ein Dictionary indexiert nach Stadt-Namen. Das macht awk fast zu einer richtigen Programmiersprache.

10) Live-Vergleich der drei

Schauen wir gleiche Aufgaben mit allen drei Tools:

grep vs. sed vs. awk – Vergleich

Zeilen mit „ERROR" anzeigen

grep

grep ERROR app.log

Anzahl ERROR-Zeilen

grep oder awk

grep -c ERROR app.log
awk '/ERROR/ {n++} END {print n}' app.log

„old" durch „new" ersetzen

sed

sed 's/old/new/g' file.txt

3. Spalte einer CSV

awk (oder cut)

awk -F',' '{print $3}' data.csv
cut -d',' -f3 data.csv

Summe Spalte 4

awk

awk -F',' '{s+=$4} END {print s}' data.csv

Zeilen entfernen die X enthalten

grep -v oder sed

grep -v X file.txt
sed '/X/d' file.txt

Eindeutige IPs aus Log

grep + sort

grep -oE "\d+\.\d+\.\d+\.\d+" log | sort -u

In der Praxis werden die drei oft kombiniert. Eine typische Pipeline: cat log | grep ERROR | awk '{print $3}' | sort | uniq -c | sort -rn | head – findet die Top-10 häufigsten Werte in Spalte 3 aller ERROR-Zeilen. Das ist die Kunst der Unix-Pipelines.

11) PowerShell-Äquivalente

Falls du auf Windows arbeitest und PowerShell nutzt: die Klassiker haben dort PowerShell-Pendants. Anders strukturiert (Objekte statt Text), aber gleiche Wirkung:

Unix	PowerShell
`grep "X" file`	`Select-String "X" file`
`grep -i`	`Select-String -CaseSensitive:$false`
`grep -v`	`Select-String -NotMatch`
`sed 's/A/B/g'`	`(Get-Content file) -replace "A","B"`
`awk '{print $3}'`	`... \| %{ ($_ -split " ")[2] }`
Spalten-Filterung	`... \| Where-Object {$_.Property -eq "X"}`

PowerShell ist objektorientiert – statt Text-Streams hat man Objekte mit Properties. Das macht manche Operationen umständlicher (für CSV-Tabellen einfacher), aber das Konzept ist identisch.

12) Praxis-Beispiele aus dem IT-Alltag

Typische Aufgaben die du mit grep/sed/awk in Minuten löst – die ohne sie Stunden bräuchten:

Real-World-Beispiele

# Wer hat heute morgen einen 500er-Fehler gesehen? $ grep "$(date +%Y-%m-%d).*500" access.log | awk '{print $1}' | sort -u # Top 10 Quell-IPs mit den meisten Requests: $ awk '{print $1}' access.log | sort | uniq -c | sort -rn | head # Alle E-Mail-Adressen aus 100 Dateien sammeln: $ grep -orE "\w+@\w+\.\w+" *.txt | sort -u > emails.txt # Speicherverbrauch pro Prozess (vereinfacht): $ ps aux | awk '{print $11, $4}' | sort -k2 -rn | head # In CSV Spalten neu ordnen: $ awk -F',' -v OFS=',' '{print $3, $1, $2}' input.csv > output.csv # Telefonnummern aus Text extrahieren: $ grep -oE "\+?[0-9]{2,4}[ /-]?[0-9]{3,}[ /-]?[0-9]{3,}" text.txt # IPs in Logfile zählen und sortieren: $ cat access.log | grep -oE "\d+\.\d+\.\d+\.\d+" | sort | uniq -c | sort -rn

Solche Befehle sind das tägliche Brot von Sysadmins, DevOps und FISIs. Bei größeren Mengen sind sie zigfach schneller als ein Python-Skript – und in einer Zeile geschrieben.

13) Wann nicht grep/sed/awk?

Auch diese mächtigen Werkzeuge haben Grenzen. Wann lieber Python oder ein Editor?

JSON-Strukturen parsen: nutze jq oder Python. Regex auf JSON ist sehr fragil.
HTML/XML: dito – richtigen Parser nutzen.
Mehrzeilige Patterns: grep/sed sind zeilen-orientiert. Mit Tricks geht's, aber Python ist klarer.
Komplexe Transformationen: wenn dein awk-Skript über 20 Zeilen wird, ist Python lesbarer und wartbarer.
Unicode-Sensible Sachen: ältere Versionen haben Probleme. Python 3 ist da robuster.

Faustregel: bis 1-2 Pipeline-Befehle → Shell mit grep/sed/awk. Komplexer → Python-Skript schreiben.

Zusammenfassung

Drei klassische Unix-Werkzeuge: grep (suchen + Zeilen ausgeben), sed (suchen + ersetzen), awk (Spalten verarbeiten, Mini-Programmiersprache). grep-Flags: -i, -v, -n, -c, -r, -A/-B/-C (Kontext), -E (ERE empfohlen), -P (PCRE), -o (nur Match). sed: s/pat/repl/g, mit -i in-place (Backup mit -i.bak!), Backrefs \1. awk: $1/$2 für Spalten, -F',' für Trenner, BEGIN/END-Blöcke. Klassische Pipelines: grep|sort|uniq -c|sort -rn für Log-Analyse. Nicht für JSON/HTML – dort echte Parser.