# tr — Zeichen übersetzen, löschen und zusammenfassen

> Praxis-Guide zu tr — Zeichen aus der Standardeingabe übersetzen, löschen oder zusammenfassen. Der Filter für zeichenweise Transformationen in Pipelines.

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

<!-- PROSE:intro -->
tr (translate) ist der Filter für zeichenweise Transformationen in der Shell – er liest von der Standardeingabe, ersetzt, löscht oder fasst einzelne Zeichen zusammen und schreibt das Ergebnis auf die Standardausgabe. Anders als sed arbeitet tr nicht mit Mustern, sondern mit Zeichenmengen: Du gibst eine Quell- und eine Zielmenge an, und tr bildet sie Zeichen für Zeichen aufeinander ab. Mit POSIX-Zeichenklassen wie `[:upper:]` oder `[:digit:]` deckst du ganze Gruppen ab, und mit `-d`, `-s` und `-c` löschst, verdichtest oder invertierst du die Auswahl. tr kennt keine Dateinamen – es lebt ausschließlich in der Pipe.
<!-- PROSE:intro:end -->

## Zeichenübersetzung

`tr '<set1>' '<set2>'` — Ersetzt Zeichen aus set1 durch die entsprechenden Zeichen in set2.

```bash
echo 'hello' | tr 'aeiou' 'AEIOU'
```

`tr 'a-z' 'A-Z'` — Wandelt Kleinbuchstaben in Großbuchstaben um.

```bash
echo 'hello world' | tr 'a-z' 'A-Z'
```

`tr 'A-Z' 'a-z'` — Wandelt Großbuchstaben in Kleinbuchstaben um.

```bash
echo 'HELLO' | tr 'A-Z' 'a-z'
```

`tr '[:lower:]' '[:upper:]'` — Wandelt Klein- in Großbuchstaben über POSIX-Zeichenklassen um.

```bash
cat file.txt | tr '[:lower:]' '[:upper:]'
```

`tr '<char>' '<char>'` — Ersetzt ein einzelnes Zeichen durch ein anderes.

```bash
echo '2024/01/15' | tr '/' '-'
```

`tr ' ' '\n'` — Ersetzt Leerzeichen durch Zeilenumbrüche (ein Wort pro Zeile).

```bash
echo 'one two three' | tr ' ' '\n'
```

`tr '\n' ' '` — Ersetzt Zeilenumbrüche durch Leerzeichen (verbindet Zeilen zu einer).

```bash
cat list.txt | tr '\n' ' '
```

`tr ',' '\t'` — Wandelt Kommas in Tabulatoren um (CSV zu TSV).

```bash
cat data.csv | tr ',' '\t' > data.tsv
```

`tr '\t' ','` — Wandelt Tabulatoren in Kommas um (TSV zu CSV).

```bash
cat data.tsv | tr '\t' ',' > data.csv
```

## Zeichen löschen

`tr -d '<chars>'` — Löscht alle Vorkommen der angegebenen Zeichen.

```bash
echo 'Hello, World!' | tr -d ',!'
```

`tr -d '[:digit:]'` — Entfernt alle Ziffern.

```bash
echo 'abc123def456' | tr -d '[:digit:]'
```

`tr -d '[:alpha:]'` — Entfernt alle Buchstaben (behält Ziffern, Satzzeichen usw.).

```bash
echo 'abc123def456' | tr -d '[:alpha:]'
```

`tr -d '[:space:]'` — Entfernt alle Leerraumzeichen (Leerzeichen, Tabs, Zeilenumbrüche).

```bash
echo '  hello   world  ' | tr -d '[:space:]'
```

`tr -d '\n'` — Entfernt alle Zeilenumbrüche (fügt alle Zeilen zusammen).

```bash
cat file.txt | tr -d '\n'
```

`tr -d '\r'` — Entfernt Wagenrückläufe (korrigiert Windows-Zeilenenden).

```bash
cat windows.txt | tr -d '\r' > unix.txt
```

`tr -d '[:punct:]'` — Entfernt alle Satzzeichen.

```bash
echo 'Hello, World! How are you?' | tr -d '[:punct:]'
```

## Wiederholungen zusammenfassen

`tr -s '<chars>'` — Fasst wiederholte Zeichen zu einem einzigen zusammen.

```bash
echo 'heeello' | tr -s 'e'
```

`tr -s ' '` — Reduziert mehrere Leerzeichen auf ein einzelnes.

```bash
echo 'too    many    spaces' | tr -s ' '
```

`tr -s '\n'` — Entfernt Leerzeilen (fasst aufeinanderfolgende Zeilenumbrüche zusammen).

```bash
cat file.txt | tr -s '\n'
```

`tr -s '[:blank:]'` — Fasst sämtlichen horizontalen Leerraum zusammen (Leerzeichen und Tabs).

```bash
cat messy.txt | tr -s '[:blank:]'
```

`tr -s ' ' '\t'` — Fasst mehrere Leerzeichen zusammen und wandelt sie in einen einzelnen Tabulator um.

```bash
ps aux | tr -s ' ' '\t'
```

## Komplement

`tr -cd '<chars>'` — Löscht alle Zeichen AUSSER den angegebenen.

```bash
echo 'abc123def456' | tr -cd '[:digit:]\n'
```

`tr -cd '[:alnum:]\n'` — Behält nur alphanumerische Zeichen und Zeilenumbrüche.

```bash
echo 'Hello, World! #123' | tr -cd '[:alnum:]\n'
```

`tr -cd '[:print:]'` — Entfernt alle nicht druckbaren Zeichen.

```bash
cat binary-mixed.txt | tr -cd '[:print:]\n'
```

`tr -c '[:alnum:]' '_'` — Ersetzt alle nicht-alphanumerischen Zeichen durch Unterstriche.

```bash
echo 'Hello World! @2024' | tr -c '[:alnum:]\n' '_'
```

## Zeichenklassen

`[:alpha:]` — Alle Buchstaben (a-z, A-Z).

```bash
tr -d '[:alpha:]'
```

`[:digit:]` — Alle Ziffern (0-9).

```bash
tr -d '[:digit:]'
```

`[:alnum:]` — Alle Buchstaben und Ziffern.

```bash
tr -cd '[:alnum:]'
```

`[:upper:] / [:lower:]` — Groß- / Kleinbuchstaben.

```bash
tr '[:upper:]' '[:lower:]'
```

`[:space:]` — Alle Leerraumzeichen (Leerzeichen, Tab, Zeilenumbruch usw.).

```bash
tr -d '[:space:]'
```

`[:blank:]` — Nur horizontaler Leerraum (Leerzeichen und Tab).

```bash
tr -s '[:blank:]'
```

`[:punct:]` — Alle Satzzeichen.

```bash
tr -d '[:punct:]'
```

`[:print:]` — Alle druckbaren Zeichen (inklusive Leerzeichen).

```bash
tr -cd '[:print:]'
```

## Typische Anwendungsfälle

`tr -dc 'a-zA-Z0-9' < /dev/urandom | head -c <n>` — Erzeugt eine zufällige alphanumerische Zeichenkette aus n Zeichen.

```bash
tr -dc 'a-zA-Z0-9' < /dev/urandom | head -c 32; echo
```

`echo '<text>' | tr '[:upper:]' '[:lower:]' | tr ' ' '-' | tr -cd '[:alnum:]-'` — Erzeugt aus einem Text einen URL-Slug.

```bash
echo 'Hello World Blog Post' | tr '[:upper:]' '[:lower:]' | tr ' ' '-'
```

`cat <file> | tr -s ' ' '\n' | sort | uniq -c | sort -rn` — Worthäufigkeit zählen: Wörter aufteilen, sortieren, zählen, nach Häufigkeit sortieren.

```bash
cat article.txt | tr -s ' ' '\n' | sort | uniq -c | sort -rn | head -20
```

`echo '<ROT13>' | tr 'A-Za-z' 'N-ZA-Mn-za-m'` — Kodiert/dekodiert eine Zeichenkette per ROT13.

```bash
echo 'Hello World' | tr 'A-Za-z' 'N-ZA-Mn-za-m'
```

`cat <file> | tr -cs '[:alpha:]' '\n'` — Extrahiert nur Wörter (eines pro Zeile) und entfernt alle nicht-alphabetischen Zeichen.

```bash
cat mixed.txt | tr -cs '[:alpha:]' '\n'
```

<!-- PROSE:outro -->
## Fazit

tr ist klein, schnell und überraschend vielseitig – ideal für Aufgaben wie Groß-/Kleinschreibung umwandeln, Windows-Zeilenenden bereinigen (`tr -d '\r'`), Whitespace verdichten oder Texte in Wortlisten zerlegen. Denk aber an seine Eigenheiten: tr ersetzt immer Zeichen für Zeichen, niemals ganze Zeichenketten – für mehrstellige Suchen-und-Ersetzen brauchst du sed. Die literalen `\n` und `\t` müssen im jeweiligen Argument stehen und werden von tr selbst interpretiert. Mit Multibyte-Zeichen (UTF-8) kommt tr nur eingeschränkt zurecht, weil es byteweise arbeitet; bei Umlauten und Sonderzeichen ist es daher nicht immer die richtige Wahl.

## Weiterführende Links

- [GNU coreutils: tr](https://www.gnu.org/software/coreutils/manual/html_node/tr-invocation.html) – offizielle Referenz mit allen Optionen und Zeichenklassen (englisch)
- [ubuntuusers-Wiki: Datenstromtools](https://wiki.ubuntuusers.de/Datenstromtools/) – deutschsprachige Übersicht zu tr, sed, cut und Co.
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [sed](https://www.jpkc.com/db/cheatsheets/files-text/sed/) – Stream-Editor für musterbasiertes Suchen und Ersetzen ganzer Zeichenketten
- [cut](https://www.jpkc.com/db/cheatsheets/files-text/cut/) – Felder, Zeichen oder Byte-Bereiche aus Zeilen herausschneiden
- [paste](https://www.jpkc.com/db/cheatsheets/files-text/paste/) – Zeilen mehrerer Dateien spaltenweise zusammenführen