# rm — Dateien und Verzeichnisse löschen > Praxis-Guide zu rm: Dateien und Verzeichnisse löschen, sicher mit -i/-I, rekursiv mit -rf und gefährliche Befehle wie rm -rf / vermeiden. Source: https://www.jpkc.com/db/cheatsheets/files-text/rm/ `rm` (remove) löscht Dateien und Verzeichnisse aus dem Dateisystem – und zwar endgültig: Anders als beim Verschieben in den Papierkorb landet hier nichts in einem Zwischenspeicher, gelöschte Daten lassen sich ohne Backup nicht wiederherstellen. Im Alltag brauchst du `rm`, um temporäre Dateien, alte Logs oder ganze Projektordner loszuwerden. Genau wegen seiner Endgültigkeit lohnt es sich, die sicheren Varianten zu kennen: `rm -i` fragt vor jeder Datei nach, `rm -I` warnt einmalig bei großen oder rekursiven Löschungen. Besondere Vorsicht gilt bei `rm -rf` in Kombination mit Variablen oder Glob-Mustern – ein leeres `$VAR` oder ein versehentliches `/*` kann ganze Systeme auslöschen. ## Grundlegendes Löschen `rm ` — Löscht eine einzelne Datei. ```bash rm temp.txt ``` `rm ` — Löscht mehrere Dateien auf einmal. ```bash rm old.log debug.log error.log ``` `rm *.tmp` — Löscht alle Dateien, die auf ein Glob-Muster passen. ```bash rm *.tmp ``` `rm -v ` — Ausführlicher Modus. Gibt jede Datei aus, während sie gelöscht wird. ```bash rm -v *.log ``` ## Interaktives & sicheres Löschen `rm -i ` — Interaktiver Modus. Fragt vor jeder Datei nach Bestätigung. ```bash rm -i important-data.* ``` `rm -I ` — Fragt einmalig nach, bevor mehr als 3 Dateien oder rekursiv gelöscht wird. ```bash rm -I *.log ``` `rm --interactive=once ` — Wie -I. Fragt einmalig bei Massenlöschungen nach. ```bash rm --interactive=once /tmp/session_* ``` `rm -f ` — Erzwingt das Löschen. Fragt nie nach und ignoriert nicht vorhandene Dateien. ```bash rm -f lockfile.pid ``` ## Verzeichnisse löschen `rm -r ` — Löscht ein Verzeichnis samt allem Inhalt rekursiv. ```bash rm -r ./old-project/ ``` `rm -rf ` — Löscht ein Verzeichnis rekursiv und ohne Nachfrage. Mit äußerster Vorsicht verwenden. ```bash rm -rf ./build/ ``` `rm -ri ` — Löscht ein Verzeichnis rekursiv, mit Bestätigung für jede Datei. ```bash rm -ri ./unknown-folder/ ``` `rm -d ` — Löscht ein leeres Verzeichnis. Schlägt fehl, wenn es nicht leer ist. ```bash rm -d ./empty-dir/ ``` `rmdir ` — Löscht ein leeres Verzeichnis (eigenständiges Kommando, wie rm -d). ```bash rmdir ./empty-dir/ ``` `rmdir -p ` — Löscht ein Verzeichnis und seine leeren übergeordneten Verzeichnisse. ```bash rmdir -p ./a/b/c/ ``` ## Sicherheitsoptionen `rm --preserve-root` — Verweigert rekursives Arbeiten auf /. Dies ist das Standardverhalten. ```bash rm -rf --preserve-root /some/path/ ``` `rm --preserve-root=all` — Lehnt zusätzlich jedes Argument ab, das ein Mountpoint ist. ```bash rm -rf --preserve-root=all /mnt/data/ ``` `rm --one-file-system -r ` — Überspringt beim rekursiven Löschen Verzeichnisse auf anderen Dateisystemen. ```bash rm -rf --one-file-system /var/tmp/ ``` ## Sonderfälle `rm -- ` — Löscht eine Datei, deren Name mit einem Bindestrich beginnt. Das -- signalisiert das Ende der Optionen. ```bash rm -- -strange-filename.txt ``` `rm ./-` — Alternative: Eine mit Bindestrich beginnende Datei löschen, indem du ./ voranstellst. ```bash rm ./-strange-filename.txt ``` `rm -f ` — Erzwingt das Löschen von Dateien mit Sonderzeichen im Namen. ```bash rm -f 'file with spaces.txt' ``` `find -inum -delete` — Löscht eine Datei anhand ihrer Inode-Nummer. Letzter Ausweg bei nicht löschbaren Dateinamen. ```bash ls -i; find . -inum 1234567 -delete ``` ## Suchen & gezielt löschen `find -name '' -delete` — Findet und löscht Dateien nach Namensmuster. Schneller als -exec rm. ```bash find . -name '*.tmp' -delete ``` `find -name '' -type f -delete` — Löscht nur Dateien (keine Verzeichnisse), die auf ein Muster passen. ```bash find . -name '.DS_Store' -type f -delete ``` `find -empty -type d -delete` — Löscht alle leeren Verzeichnisse innerhalb eines Baums. ```bash find ./project/ -empty -type d -delete ``` `find -mtime + -delete` — Löscht Dateien, die älter als N Tage sind. ```bash find /var/log/ -name '*.log' -mtime +90 -delete ``` `find -size + -delete` — Löscht Dateien, die größer als eine bestimmte Größe sind. ```bash find /tmp/ -size +100M -delete ``` `find -name '' -print -delete` — Gibt jede Datei vor dem Löschen aus (Kontrollausgabe). ```bash find . -name '*.bak' -print -delete ``` `find -name '' -print0 | xargs -0 rm -v` — Findet und löscht Dateien sicher mit ausführlicher Ausgabe. Kommt mit Leerzeichen in Dateinamen zurecht. ```bash find . -name '*.cache' -print0 | xargs -0 rm -v ``` ## Sicherere Alternativen `mv /tmp/` — Statt Löschen nach /tmp verschieben. Dateien werden beim Neustart aufgeräumt. ```bash mv suspicious-file.dat /tmp/ ``` `trash-put ` — Verschiebt eine Datei in den Papierkorb (Paket trash-cli). Lässt sich später wiederherstellen. ```bash trash-put document.pdf ``` `trash-list` — Listet alle Dateien im Papierkorb auf (trash-cli). ```bash trash-list ``` `trash-restore` — Stellt interaktiv eine Datei aus dem Papierkorb wieder her (trash-cli). ```bash trash-restore ``` `trash-empty` — Leert den Papierkorb endgültig (trash-cli). ```bash trash-empty ``` `alias rm='rm -I'` — Shell-Alias, der vor Massenlöschungen immer nachfragt. ```bash alias rm='rm -I' ``` ## Gefährliche Befehle, die du vermeiden solltest `rm -rf /` — NIEMALS AUSFÜHREN. Versucht, das gesamte Dateisystem zu löschen. Wird durch das standardmäßige --preserve-root blockiert. ```bash # DO NOT RUN — destroys your entire system ``` `rm -rf /*` — NIEMALS AUSFÜHREN. Umgeht --preserve-root, indem /* zu einzelnen Pfaden expandiert. Löscht alles. ```bash # DO NOT RUN — the glob expansion bypasses root protection ``` `rm -rf $VARIABLE/` — GEFÄHRLICH, wenn die Variable leer oder nicht gesetzt ist. Expandiert zu rm -rf / und löscht alles. ```bash # ALWAYS quote and check: rm -rf "${DIR:?Variable not set}/" ``` `rm -rf "${DIR:?}"/*` — Sicheres Muster. Das :? lässt die Shell mit einem Fehler abbrechen, falls DIR leer oder nicht gesetzt ist. ```bash DIR=/var/cache/app; rm -rf "${DIR:?Variable not set}"/* ``` ## Fazit `rm` ist mächtig und endgültig: Es kennt keinen Papierkorb, und einmal gelöschte Daten sind ohne Backup verloren. Für den Alltag reichen meist `rm `, `rm -r ` und beim Aufräumen die `find … -delete`-Muster. Mach dir die gefährlichen Fälle bewusst: `rm -rf` mit einer leeren Variable, einem versehentlichen Leerzeichen vor `/` oder einem `/*` kann ein ganzes System auslöschen. Zwei einfache Gewohnheiten schützen dich – quote und prüfe Variablen mit `"${DIR:?}"`, und setze einen `alias rm='rm -I'`, damit die Shell vor Massenlöschungen nachfragt. Wenn du Wiederherstellbarkeit brauchst, nutze `trash-cli` statt `rm`. ## Weiterführende Links - [GNU Coreutils: rm](https://www.gnu.org/software/coreutils/manual/html_node/rm-invocation.html) – offizielle Referenz zu allen Optionen (englisch) - [ubuntuusers-Wiki: rm](https://wiki.ubuntuusers.de/rm/) – deutschsprachige Einführung mit Praxisbeispielen ## Verwandte Kommandos - [mv](https://www.jpkc.com/db/cheatsheets/files-text/mv/) – Dateien verschieben oder umbenennen statt löschen - [cp](https://www.jpkc.com/db/cheatsheets/files-text/cp/) – Dateien und Verzeichnisse kopieren - [find](https://www.jpkc.com/db/cheatsheets/files-text/find/) – Dateien suchen und gezielt mit -delete entfernen