sed — Stream-Editor zum Transformieren von Text

sed (Stream-Editor) liest Text Zeile für Zeile und wendet Editierbefehle an, während die Daten durchfließen – kein interaktiver Editor, keine temporären Dateien. Sein Brot-und-Butter-Geschäft ist das Suchen und Ersetzen mit s/Muster/Ersatz/, aber es löscht, fügt ein, gibt aus und ordnet Zeilen um, adressiert per Nummer oder per Regex. Du greifst immer dann darauf zurück, wenn du Konfigurationsdateien patchen, URLs umschreiben, Whitespace entfernen oder Befehlsausgaben in einer Pipeline aufbereiten musst. Dieser Guide führt vom einfachen Ersetzen über die In-Place-Bearbeitung und Zeilenadressierung bis zu Rückbezügen und den Rezepten, die du wirklich nutzt.

Grundlegendes Ersetzen

sed 's/<pattern>/<replacement>/' <file> — Ersetzt das erste Vorkommen des Musters in jeder Zeile.

sed 's/foo/bar/' input.txt

sed 's/<pattern>/<replacement>/g' <file> — Ersetzt alle Vorkommen des Musters in jeder Zeile (global).

sed 's/foo/bar/g' input.txt

sed 's/<pattern>/<replacement>/gi' <file> — Ersetzt alle Vorkommen, ohne Beachtung der Groß-/Kleinschreibung.

sed 's/error/warning/gi' log.txt

sed 's/<pattern>/<replacement>/2' <file> — Ersetzt nur das N-te Vorkommen des Musters in jeder Zeile.

sed 's/the/THE/2' input.txt

sed 's/<pattern>/<replacement>/gp' <file> — Ersetzt global und gibt nur die geänderten Zeilen aus (zusammen mit -n).

sed -n 's/error/ERROR/gp' log.txt

In-Place-Bearbeitung

sed -i 's/<pattern>/<replacement>/g' <file> — Bearbeitet die Datei in-place (ändert die Originaldatei direkt).

sed -i 's/localhost/production.example.com/g' config.yml

sed -i.bak 's/<pattern>/<replacement>/g' <file> — Bearbeitet in-place und legt ein Backup mit dem angegebenen Suffix an.

sed -i.bak 's/debug=true/debug=false/g' config.ini

sed -i '' 's/<pattern>/<replacement>/g' <file> — Bearbeitet in-place ohne Backup (macOS-/BSD-Syntax, leeres Suffix erforderlich).

sed -i '' 's/old/new/g' config.yml

sed -i 's/<pattern>/<replacement>/g' <file1> <file2> — Bearbeitet mehrere Dateien in-place mit derselben Ersetzung.

sed -i 's/v1.0/v2.0/g' README.md CHANGELOG.md

Trennzeichen & Sonderzeichen

sed 's|<pattern>|<replacement>|g' <file> — Verwendet | statt / als Trennzeichen. Nützlich, wenn Muster Schrägstriche enthalten.

sed 's|/usr/local|/opt|g' paths.conf

sed 's#<pattern>#<replacement>#g' <file> — Verwendet # als Trennzeichen. Jedes Zeichen kann als Trennzeichen dienen.

sed 's#http://#https://#g' urls.txt

sed 's/[[:space:]]*$//' <file> — Entfernt nachgestellten Whitespace aus jeder Zeile.

sed 's/[[:space:]]*$//' source.py

sed 's/^[[:space:]]*//' <file> — Entfernt führenden Whitespace aus jeder Zeile.

sed 's/^[[:space:]]*//' messy.txt

sed 's/&/\&/g; s/</\</g; s/>/\>/g' <file> — Maskiert HTML-Sonderzeichen.

sed 's/&/\&amp;/g; s/</\&lt;/g; s/>/\&gt;/g' input.html

Adressierung (Zeilen gezielt ansprechen)

sed '<n>s/<pattern>/<replacement>/' <file> — Ersetzt nur in einer bestimmten Zeilennummer.

sed '3s/old/new/' config.txt

sed '<n>,<m>s/<pattern>/<replacement>/g' <file> — Ersetzt in einem Zeilenbereich (von Zeile n bis Zeile m).

sed '10,20s/foo/bar/g' data.txt

sed '$s/<pattern>/<replacement>/' <file> — Ersetzt nur in der letzten Zeile. $ adressiert die letzte Zeile.

sed '$s/$/;/' data.csv

sed '/<regex>/s/<pattern>/<replacement>/g' <file> — Ersetzt nur in Zeilen, die auf ein Regex-Muster passen.

sed '/^#/s/TODO/DONE/g' script.sh

sed '/<start>/,/<end>/s/<pattern>/<replacement>/g' <file> — Ersetzt innerhalb eines durch zwei Regex-Muster definierten Bereichs.

sed '/<body>/,/<\/body>/s/class="old"/class="new"/g' page.html

sed '1,/<pattern>/s/<old>/<new>/g' <file> — Ersetzt ab der ersten Zeile bis zum ersten Treffer eines Musters.

sed '1,/---/s/draft/published/g' post.md

sed '0~2s/<pattern>/<replacement>/g' <file> — Ersetzt in jeder 2. Zeile (GNU-sed-Schrittadresse: start~step).

sed '0~2s/^/>> /' data.txt

Zeilen löschen

sed '<n>d' <file> — Löscht eine bestimmte Zeile anhand ihrer Nummer.

sed '5d' data.txt

sed '<n>,<m>d' <file> — Löscht einen Zeilenbereich.

sed '3,7d' data.txt

sed '$d' <file> — Löscht die letzte Zeile der Datei.

sed '$d' data.txt

sed '/<pattern>/d' <file> — Löscht alle Zeilen, die auf ein Muster passen.

sed '/^#/d' config.ini

sed '/^$/d' <file> — Löscht alle Leerzeilen.

sed '/^$/d' messy.txt

sed '/^[[:space:]]*$/d' <file> — Löscht alle leeren Zeilen (leer oder nur Whitespace).

sed '/^[[:space:]]*$/d' messy.txt

sed '/<start>/,/<end>/d' <file> — Löscht alle Zeilen zwischen zwei Mustern (einschließlich).

sed '/BEGIN_GENERATED/,/END_GENERATED/d' output.txt

sed '/<pattern>/!d' <file> — Löscht alle Zeilen, die NICHT auf ein Muster passen (umgekehrt, wie grep).

sed '/ERROR/!d' log.txt

Einfügen & Anhängen

sed '<n>i\<text>' <file> — Fügt Text vor einer bestimmten Zeile ein.

sed '1i\# Configuration File' config.ini

sed '<n>a\<text>' <file> — Hängt Text nach einer bestimmten Zeile an.

sed '5a\# New section starts here' config.ini

sed '/<pattern>/i\<text>' <file> — Fügt Text vor Zeilen ein, die auf ein Muster passen.

sed '/\[database\]/i\# Database settings' config.ini

sed '/<pattern>/a\<text>' <file> — Hängt Text nach Zeilen an, die auf ein Muster passen.

sed '/^server {/a\    listen 443 ssl;' nginx.conf

sed '<n>c\<text>' <file> — Ersetzt (ändert) eine ganze Zeile durch neuen Text.

sed '3c\new_value = true' config.ini

sed '/<pattern>/c\<text>' <file> — Ersetzt ganze Zeilen, die auf ein Muster passen, durch neuen Text.

sed '/^debug=/c\debug=false' config.ini

Rückbezüge & Gruppen

sed 's/$<pattern>$/\1<suffix>/g' <file> — Erfasst eine Gruppe mit ( ) und referenziert sie mit \1 im Ersatz.

sed 's/\(version\)=.*/\1=2.0/' config.ini

sed -E 's/(<pattern>)/\1<suffix>/g' <file> — Erweiterter Regex-Modus. Nutzt ( ) für Gruppen statt ( ).

sed -E 's/(version)=.*/\1=2.0/' config.ini

sed -E 's/(<p1>)(<p2>)/\2\1/g' <file> — Vertauscht zwei erfasste Gruppen per Rückbezug.

sed -E 's/([a-z]+), ([a-z]+)/\2 \1/g' names.txt

sed 's/.*/(&)/' <file> — Das & im Ersatz verweist auf den gesamten gefundenen Text.

sed 's/.*/(&)/' list.txt

sed -E 's/([0-9]{4})-([0-9]{2})-([0-9]{2})/\3.\2.\1/g' <file> — Formatiert Datumsangaben von YYYY-MM-DD nach DD.MM.YYYY mit drei Gruppen um.

sed -E 's/([0-9]{4})-([0-9]{2})-([0-9]{2})/\3.\2.\1/g' dates.txt

Ausgeben & Ausgabe steuern

sed -n '<n>p' <file> — Gibt nur eine bestimmte Zeile aus. -n unterdrückt die Standardausgabe.

sed -n '10p' data.txt

sed -n '<n>,<m>p' <file> — Gibt einen Zeilenbereich aus.

sed -n '5,15p' data.txt

sed -n '/<pattern>/p' <file> — Gibt nur Zeilen aus, die auf ein Muster passen (wie grep).

sed -n '/ERROR/p' log.txt

sed -n '/<start>/,/<end>/p' <file> — Gibt Zeilen zwischen zwei Mustern aus (einschließlich).

sed -n '/BEGIN/,/END/p' config.txt

sed -n '$=' <file> — Gibt die Gesamtzahl der Zeilen in der Datei aus (wie wc -l).

sed -n '$=' data.txt

sed '/<pattern>/q' <file> — Beendet nach der Ausgabe der ersten Zeile, die auf ein Muster passt.

sed '/^END$/q' stream.txt

Mehrere Befehle

sed -e 's/<p1>/<r1>/g' -e 's/<p2>/<r2>/g' <file> — Wendet mehrere Ersetzungsbefehle mit -e-Flags an.

sed -e 's/foo/bar/g' -e 's/baz/qux/g' input.txt

sed 's/<p1>/<r1>/g; s/<p2>/<r2>/g' <file> — Verkettet mehrere Befehle mit Semikolons.

sed 's/http/https/g; s/www\.//g' urls.txt

sed -f <script_file> <file> — Liest sed-Befehle aus einer Skriptdatei (ein Befehl pro Zeile).

sed -f transforms.sed input.txt

sed '{ s/<p1>/<r1>/g; s/<p2>/<r2>/g; }' <file> — Gruppiert mehrere Befehle mit geschweiften Klammern.

sed '/^title/{ s/old/new/g; s/draft/final/g; }' document.md

Transliteration

sed 'y/<source_chars>/<dest_chars>/' <file> — Transliteriert Zeichen (wie tr). Bildet jedes Zeichen eins zu eins ab.

sed 'y/abc/ABC/' input.txt

sed 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/' <file> — Wandelt alle Großbuchstaben in Kleinbuchstaben um.

sed 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/' input.txt

Häufige Rezepte

sed -E 's/^[[:space:]]+|[[:space:]]+$//g' <file> — Entfernt führenden und nachgestellten Whitespace aus jeder Zeile.

sed -E 's/^[[:space:]]+|[[:space:]]+$//g' messy.txt

sed '/^$/N;/^\n$/d' <file> — Fasst mehrere aufeinanderfolgende Leerzeilen zu einer zusammen.

sed '/^$/N;/^\n$/d' messy.txt

sed 's/^/ /' <file> — Rückt jede Zeile um 4 Leerzeichen ein.

sed 's/^/    /' code.py

sed '=' <file> | sed 'N;s/\n/\t/' — Stellt jeder Zeile eine Zeilennummer gefolgt von einem Tabulator voran.

sed '=' script.sh | sed 'N;s/\n/\t/'

sed -E 's/([^ ]+)/"\1"/g' <file> — Setzt jedes Wort in doppelte Anführungszeichen.

sed -E 's/([^ ]+)/"\1"/g' words.txt

sed -E 's/,.*//' <file> — Extrahiert das erste Feld aus einer CSV (alles vor dem ersten Komma).

sed -E 's/,.*//' data.csv

sed -e :a -e '/\\$/N; s/\\\n//; ta' <file> — Verbindet Zeilen, die mit einem Backslash enden (Zeilenfortsetzung).

sed -e :a -e '/\\$/N; s/\\\n//; ta' Makefile

Pipelines

<command> | sed 's/<pattern>/<replacement>/g' — Nutzt sed als Filter in einer Pipeline, um Ausgaben zu transformieren.

cat /etc/passwd | sed 's/:.*//'

<command> | sed -n '/<pattern>/p' — Filtert die Ausgabe, sodass nur passende Zeilen erscheinen.

env | sed -n '/^PATH/p'

<command> | sed '1d' — Entfernt die erste Zeile (Kopfzeile) aus der Befehlsausgabe.

docker ps | sed '1d'

<command> | sed 's/\x1b\[[0-9;]*m//g' — Entfernt ANSI-Farbcodes aus der Befehlsausgabe.

ls --color=always | sed 's/\x1b\[[0-9;]*m//g'

Fazit

sed verwandelt wiederkehrende Textänderungen in Einzeiler, die du in Skripte und Pipelines einbauen kannst. Im Alltag decken s///g, das Löschen von Zeilen mit d und das gezielte Ausgeben mit -n …p die meisten Fälle ab. Die eine Option, die Respekt verdient, ist -i: Sie überschreibt die Originaldatei ohne Rückgängig-Funktion – gewöhne dir daher an, -i.bak zu schreiben, um ein Backup zu behalten, oder führe den Befehl erst ohne -i aus und prüfe die Ausgabe. Beachte die GNU-/BSD-Unterschiede: GNU-sed nimmt -i ohne Argument, BSD-/macOS-sed verlangt sed -i ''; auch Schrittadressen wie 0~2 und \x1b-Escapes sind GNU-Erweiterungen.

Weiterführende Links

GNU-sed-Handbuch – vollständige Referenz mit allen Befehlen und Adressierungsmodi (englisch)
ubuntuusers-Wiki: sed – deutschsprachige Einführung mit vielen Beispielen