Textverarbeitung: sed, awk, cut, sort

Wenn du als FISI arbeitest, verbringst du einen erheblichen Teil deiner Zeit mit Text-Verarbeitung: Logfiles durchsuchen, CSV-Daten umwandeln, Konfigurationsdateien anpassen, Server-Output parsen. Die klassischen Unix-Tools dafür sind in den 70ern entstanden und werden heute genauso intensiv genutzt wie damals – weil sie unschlagbar mächtig sind.

In dieser Lektion lernst du die wichtigsten: grep (suchen), sed (ersetzen), awk (Spalten verarbeiten), cut, sort, uniq, tr. Jedes davon allein ist nützlich – aber die wahre Stärke kommt durch Pipes, die diese Werkzeuge verketten. Für richtig komplexe Aufgaben greift man später zu Python – aber für 80% aller Textaufgaben reichen diese Tools.

1) Die Werkzeugkiste im Überblick

Ein Überblick was welches Tool macht. Sie ergänzen sich:

Textverarbeitungs-Tools im Schnellüberblick

grep

Sucht Zeilen die ein Pattern enthalten. Filter nach Inhalt.

sed

Stream-Editor. Sucht und ersetzt Text. Mächtig mit Regex.

awk

Spalten-Magier. Tabellen verarbeiten, Berechnungen.

cut

Schneidet Spalten aus (nach Zeichen oder Trenner).

sort

Sortiert Zeilen alphabetisch oder numerisch.

uniq

Entfernt direkte Duplikate (nach sort!).

Translate. Ersetzt einzelne Zeichen, z.B. groß→klein.

Zählt Zeilen, Wörter, Bytes (kennst du aus L2).

Diese Tools folgen alle der Unix-Philosophie: ein Tool, eine Aufgabe, perfekt umgesetzt, Ein-/Ausgabe über Streams. Du verkettest sie mit Pipes zu beliebig komplexen Verarbeitungen. Diese Modularität ist seit 50 Jahren das Vorbild guten Software-Designs.

2) Live-Sandbox: Tools ausprobieren

Hier kannst du die wichtigsten Operationen auf einer Beispiel-CSV-Datei live testen. Wähle ein Tool und sieh wie es das Ergebnis verändert:

Live-Sandbox

Eingabe (users.csv)

id;name;rolle;mail 1;Anna;admin;anna@example.com 2;Bob;user;bob@example.com 3;Carla;admin;carla@example.com 4;Dirk;user;dirk@example.com 5;Eva;user;eva@example.com

$ < users.csv

Ausgabe

Jedes dieser Tools liest standardmäßig von stdin und schreibt nach stdout (siehe L3 Streams). Das macht sie perfekt für Pipes: cat datei | grep "x" | sort | uniq. Probier zur Übung verschiedene Kombinationen auf eigene Daten.

3) grep – die wichtigsten Optionen vertieft

Du kennst grep schon aus L2. Hier die Optionen die in der Praxis wirklich zählen:

# Standard: alle Zeilen die Pattern enthalten grep "ERROR" log.txt # Case-insensitive (Groß/Klein egal) grep -i "error" log.txt # Mit Zeilennummern grep -n "ERROR" log.txt # Invertiert: alles AUSSER dem Pattern grep -v "DEBUG" log.txt # Nur Anzahl der Treffer grep -c "ERROR" log.txt # Rekursiv durch ganze Verzeichnisse grep -r "TODO" src/ # Erweiterte Regex (mehr Features) grep -E "ERROR|FATAL|CRITICAL" log.txt # Nur ganze Wörter matchen grep -w "test" log.txt # nicht "tested" o.ä. # Kontext: 3 Zeilen vor und nach Treffer grep -B 3 -A 3 "ERROR" log.txt grep -C 3 "ERROR" log.txt # gleichbedeutend

Häufiges Pattern für Server-Admins: grep -rn "TODO" . findet alle TODO-Kommentare in allen Code-Dateien mit Datei + Zeilennummer. Oder: tail -f /var/log/syslog | grep --line-buffered "ERROR" zeigt live nur Fehler aus dem System-Log.

4) Reguläre Ausdrücke – Pattern-Magie

grep, sed und awk können mit Regular Expressions (Regex) suchen. Das ist eine eigene kleine Mini-Sprache für Suchmuster. Hier die wichtigsten Bausteine:

Regex-Cheat-Sheet

beliebiges Zeichen

^abc

Anfang der Zeile

abc$

Ende der Zeile

[abc]

eines von a, b, c

[^abc]

KEIN a, b, c

[0-9]

eine Ziffer

[a-zA-Z]

Buchstabe

0 oder mehr a

1 oder mehr a (in -E)

0 oder 1 a (in -E)

a{3}

genau 3 a

a{2,5}

2 bis 5 a

a|b

a ODER b (in -E)

(abc)

Gruppe (in -E)

Ziffer (in grep -P)

Whitespace (in grep -P)

Zwei Regex-Dialekte: BRE (Basic) ist Default in grep/sed, hat weniger Features. ERE (Extended) kennt +, ?, |, () direkt – einschaltbar mit grep -E oder sed -E. PCRE ist die Perl-kompatible Version mit allen Features (\d, \s, Lookahead) – mit grep -P. Beispiele: grep -E "^(GET|POST) /api" findet HTTP-Requests, grep -E "[0-9]{3}-[0-9]{4}" Telefonnummern.

5) sed – Stream Editor für Such-und-Ersetz

sed liest Text Zeile für Zeile und führt Edit-Befehle aus. Der häufigste Anwendungsfall ist Substitution mit dem s/alt/neu/-Befehl:

# Einfache Ersetzung – ERSTES Vorkommen pro Zeile sed 's/alt/neu/' datei.txt # ALLE Vorkommen pro Zeile (global) sed 's/alt/neu/g' datei.txt # Case-insensitive sed 's/alt/neu/gi' datei.txt # In Datei schreiben (in-place edit) sed -i 's/alt/neu/g' datei.txt # Mit Backup vor Änderung sed -i.bak 's/alt/neu/g' datei.txt # Andere Trennzeichen (wenn / im Text) sed 's|/home/anna|/home/bob|g' datei.txt # Nur bestimmte Zeilen ändern (Adress-Range) sed '1,10 s/alt/neu/g' datei.txt # Zeilen 1-10 sed '/ERROR/ s/foo/bar/g' datei.txt # nur Zeilen mit ERROR # Zeilen löschen sed '/^#/d' config.txt # Kommentar-Zeilen weg sed '/^$/d' datei.txt # Leerzeilen weg # Mit Regex – Capture-Groups mit \1, \2 echo "Hallo Anna" | sed -E 's/(\w+) (\w+)/\2 \1/' # → Anna Hallo

sed ist sehr mächtig – es kann theoretisch wie ein vollständiges Programm arbeiten (Schleifen, bedingte Befehle, Skript-Dateien). In der Praxis nutzen 95% der Leute es nur für s/.../.../g. Für komplexere Manipulationen lieber zu awk oder Python greifen.

6) awk – Programmiersprache für Tabellen

awk ist mehr als ein Tool – es ist eine ganze Mini-Programmiersprache, speziell für Text in Zeilen-mit-Spalten. Es liest Eingabe Zeile für Zeile, splittet jede Zeile automatisch in Felder (Default: Whitespace), und führt Code pro Zeile aus:

# Grundform: awk 'pattern { aktion }' datei # Jede Zeile ausgeben (Standardverhalten) awk '{print}' datei.txt # Nur 2. Spalte ausgeben awk '{print $2}' datei.txt # Mehrere Spalten awk '{print $1, $3}' datei.txt # Mit anderem Trenner (z.B. CSV mit Komma) awk -F"," '{print $2}' daten.csv # Bedingung: nur Zeilen wo Spalte 3 = "admin" awk -F";" '$3 == "admin"' users.csv # Mit Berechnung awk '{summe += $2} END {print summe}' zahlen.txt # Formatierte Ausgabe awk '{printf "%-20s %5d\n", $1, $2}' datei.txt

Awk hat eingebaute Variablen die du kennen solltest:

awk-Spezialvariablen

die ganze aktuelle Zeile

$1, $2, ...

Spalte 1, 2, ...

$NF

die letzte Spalte

Number of Fields (Spalten-Anzahl)

Number of Record (Zeilennummer)

Field Separator (Trenner)

OFS

Output Field Separator

BEGIN { }

vor erster Zeile ausführen

END { }

nach letzter Zeile (für Summen!)

Klassiker: aus einer Apache-Access-Log die häufigsten IPs zählen: awk '{print $1}' access.log | sort | uniq -c | sort -rn | head -10. Erst extrahieren wir Spalte 1 (IP), dann sortieren, dann mit uniq -c zählen, nochmal numerisch absteigend sortieren, Top 10. Eine Zeile die Stunden Excel-Arbeit ersetzt.

7) cut – einfache Spalten-Extraktion

Wenn awk overkill ist und du nur eine Spalte rausziehen willst: cut ist schlanker. Mit Trenner-Zeichen (-d) und Feld-Nummer (-f):

# Nach Komma trennen, Spalte 2 nehmen cut -d"," -f2 daten.csv # Mehrere Spalten cut -d":" -f1,3,5 /etc/passwd # Spalten 2 bis 5 cut -d"," -f2-5 daten.csv # Nach Zeichen-Position (nicht nach Trenner) cut -c1-10 datei.txt # erste 10 Zeichen pro Zeile # Klassisches Beispiel: Usernamen aus /etc/passwd cut -d":" -f1 /etc/passwd

cut ist limitiert (keine komplexen Trenner, kein Filtern) – aber für simple Spalten-Extraktion schneller getippt als awk. Praktisch wenn die Daten klar tabuliert sind.

8) sort und uniq – Reihenfolge und Duplikate

Diese zwei Tools werden fast immer zusammen verwendet. uniq entfernt nur direkt aufeinanderfolgende Duplikate – deshalb meistens sort | uniq:

# Alphabetisch sortieren sort namen.txt # Rückwärts sort -r namen.txt # Numerisch (sonst wird "10" vor "2" sortiert) sort -n zahlen.txt # Nach bestimmter Spalte (mit -k, getrennt durch -t) sort -t";" -k2 users.csv # Numerisch und rückwärts (Größte zuerst) sort -rn zahlen.txt # Eindeutig (entfernt Duplikate gleich) sort -u datei.txt # uniq nach sort sort datei.txt | uniq # Mit Zähler: wie oft kommt jede Zeile vor? sort datei.txt | uniq -c # Nur Duplikate zeigen (nicht die uniquen) sort datei.txt | uniq -d

Eine typische Anwendung: aus einer Log-Datei die häufigsten Fehlermeldungen finden – grep "ERROR" log.txt | sort | uniq -c | sort -rn. Erst Fehler extrahieren, sortieren (gleiche Fehler nebeneinander), zählen, nach Häufigkeit sortieren. Genial einfach.

9) tr – einzelne Zeichen ersetzen

Wenn du nur Zeichen-Ersetzungen brauchst (nicht ganze Strings), ist tr schneller als sed:

# Groß zu Klein echo "HALLO" | tr 'A-Z' 'a-z' # Leerzeichen zu Unterstrich echo "hello world" | tr ' ' '_' # Zeichen löschen echo "H-a-l-l-o" | tr -d '-' # Mehrfache Vorkommen auf eins zusammenfassen echo "hello world" | tr -s ' ' # Tabs zu Leerzeichen tr '\t' ' ' < tabbed.txt

10) Klassische Pipelines aus der Praxis

Hier sind Pipeline-Klassiker die du im Server-Alltag sehen wirst:

Pipeline-Klassiker

cat /var/log/access.log | awk '{print $1}' | sort | uniq -c | sort -rn | head -10

152 192.168.1.42 98 10.0.0.5 67 192.168.1.7 ...

→ Top 10 IPs aus Apache-Log

cut -d":" -f1 /etc/passwd | sort

anna bob daemon nobody root ...

→ Sortierte Liste aller Benutzer

find . -name "*.log" | xargs grep -l "FATAL"

./app.log ./service-2026-05-15.log

→ Welche Logs enthalten FATAL? (mehr L8 find/xargs)

ps aux | awk '$3 > 50'

user 1234 75.3 12.4 ... heavy-process user 5678 60.1 8.2 ... another-cpu-hog

→ Prozesse mit > 50% CPU

grep -c "ERROR" *.log | grep -v ":0$"

app.log:23 service.log:7

→ Logs mit Fehlern, Anzahl je Datei

Diese Patterns wirst du täglich brauchen. Pro-Tipp: speichere dir die guten in deinem persönlichen Cheat-Sheet oder als Aliases in der ~/.bashrc: alias topip='awk "{print \$1}" /var/log/access.log | sort | uniq -c | sort -rn | head' – ein Wort statt langer Pipeline.

11) Wann zu Python wechseln?

Bash-Pipelines sind mächtig – aber haben Grenzen. Wenn du eines davon brauchst, lieber zu Python greifen:

Echte JSON/XML/YAML-Parser (Bash kann nur Ausnahmen mit jq für JSON)
Komplexe Datenstrukturen (Dicts, verschachtelt)
Mathematische Berechnungen über simple Summen hinaus
Wenn dein Skript > 100 Zeilen wird
Wenn Tests, Wartbarkeit oder Wiederverwendung wichtig sind

Faustregel: Bash für Glue-Code zwischen Programmen und einfache Transformationen. Python für echte Datenverarbeitung mit Logik. Das ist auch die übliche DevOps-Praxis: Bash für Deploy-Steps, Python für komplexere Tools.

Zusammenfassung

grep: Zeilen filtern. -i case-insensitive, -v invertieren, -n Zeilennummern, -r rekursiv, -E erweiterte Regex, -A/-B/-C N Kontext. sed: Stream-Editor, vor allem s/alt/neu/g. -i in-place, -E erweiterte Regex. awk: Spalten-Programmiersprache. $1, $2, $NF Spalten, NF Anzahl, NR Zeilennr, BEGIN/END Blöcke. -F Trenner setzen. cut: einfache Spalten-Extraktion mit -d und -f. sort: -n numerisch, -r rückwärts, -k nach Spalte, -u uniq. uniq: nur nach sort, -c zählen, -d nur Duplikate. tr: Zeichen-Ersetzung. Verkettung via Pipes ist DAS Killer-Feature. Klassiker: sort | uniq -c | sort -rn = „häufigste Werte zählen".