# sed — Stream-Editor zum Transformieren von Text

> Text mit sed filtern und transformieren — Ersetzen, In-Place-Bearbeitung, Zeilenadressierung, Löschen und Rückbezüge für Skripte und Pipelines.

Source: https://www.jpkc.com/db/cheatsheets/files-text/sed/

<!-- PROSE:intro -->
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.
<!-- PROSE:intro:end -->

## Grundlegendes Ersetzen

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

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

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

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

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

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

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

```bash
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).

```bash
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).

```bash
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.

```bash
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).

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

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

```bash
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.

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

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

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

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

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

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

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

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

```bash
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.

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

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

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

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

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

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

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

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

```bash
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.

```bash
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).

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

## Zeilen löschen

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

```bash
sed '5d' data.txt
```

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

```bash
sed '3,7d' data.txt
```

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

```bash
sed '$d' data.txt
```

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

```bash
sed '/^#/d' config.ini
```

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

```bash
sed '/^$/d' messy.txt
```

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

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

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

```bash
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).

```bash
sed '/ERROR/!d' log.txt
```

## Einfügen & Anhängen

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

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

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

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

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

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

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

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

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

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

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

```bash
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.

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

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

```bash
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.

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

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

```bash
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.

```bash
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.

```bash
sed -n '10p' data.txt
```

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

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

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

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

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

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

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

```bash
sed -n '$=' data.txt
```

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

```bash
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.

```bash
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.

```bash
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).

```bash
sed -f transforms.sed input.txt
```

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

```bash
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.

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

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

```bash
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.

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

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

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

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

```bash
sed 's/^/    /' code.py
```

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

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

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

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

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

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

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

```bash
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.

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

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

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

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

```bash
docker ps | sed '1d'
```

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

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

<!-- PROSE:outro -->
## 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](https://www.gnu.org/software/sed/manual/sed.html) – vollständige Referenz mit allen Befehlen und Adressierungsmodi (englisch)
- [ubuntuusers-Wiki: sed](https://wiki.ubuntuusers.de/sed/) – deutschsprachige Einführung mit vielen Beispielen
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [awk](https://www.jpkc.com/db/cheatsheets/files-text/awk/) – feldbasierte Textverarbeitung für Spaltendaten und Auswertungen
- [grep](https://www.jpkc.com/db/cheatsheets/files-text/grep/) – erst die Zeilen finden, dann mit sed transformieren
- [tr](https://www.jpkc.com/db/cheatsheets/files-text/tr/) – schnelle zeichenweise Übersetzung und Löschung