Dateien umbenennen, verschieben, sortieren und aufräumen in Bash

1. mv sicher einsetzen — Überschreibschutz und Backups

Das mv-Kommando ist das grundlegendste Werkzeug für das Verschieben und Umbenennen von Dateien in der Shell. Ohne zusätzliche Flags überschreibt mv die Zieldatei ohne Warnung und ohne Undo-Möglichkeit. In Automatisierungsskripten, die mit Dateien umbenennen oder verschieben arbeiten, ist das ein ernstes Risiko. Das Flag -n (no-clobber) verhindert das Überschreiben: Wenn die Zieldatei existiert, bricht mv -n ohne Fehlermeldung und ohne Aktion ab. Das Flag -b erstellt ein Backup der Zieldatei bevor sie überschrieben wird – standardmäßig als datei~, konfigurierbar über --backup=numbered für nummerierte Backups.

Für kritische Dateioperationen empfiehlt sich ein zweistufiges Muster: zuerst mit -n prüfen ob das Ziel frei ist, dann mit explizitem Backup verschieben. In Skripten, die viele Dateien in einem Batch verschieben, ist es sinnvoll, vor jeder Operation zu prüfen, ob Quelle und Ziel verschieden sind, ob die Quelldatei tatsächlich existiert und ob der Ziel-Pfad als Verzeichnis vorhanden ist. Diese defensiven Prüfungen machen das Skript robust gegenüber unvollständigen Vorbedingungen und liefern klare Fehlermeldungen statt stiller Fehlschläge.

Ein wichtiger Aspekt beim Verschieben von Dateien über Dateisystemgrenzen hinweg: Auf demselben Dateisystem ist mv eine reine Inode-Operation und sofort abgeschlossen. Über Dateisystemgrenzen hinweg muss mv die Datei kopieren und dann die Quelle löschen, was bei großen Dateien Zeit braucht und bei Unterbrechung zur Situation führen kann, dass die Datei sowohl an der Quelle als auch (halb) am Ziel existiert. Für das Verschieben großer Dateien über Netzwerke oder separate Dateisysteme ist rsync --remove-source-files das robustere Werkzeug.

2. Umbenennen mit Bash-Parameterexpansion

Bash bietet mit der Parameterexpansion leistungsfähige Möglichkeiten zum Umbenennen von Dateien, ohne externe Tools starten zu müssen. Das häufigste Muster: Dateiendungen austauschen mit ${filename%.jpg}.webp oder Präfixe entfernen mit ${filename#prefix_}. Diese Operationen laufen als Builtins ohne Subshell-Overhead und sind ideal für das Umbenennen in engen Schleifen mit vielen Dateien. Das //-Muster in Parameterexpansionen ersetzt alle Vorkommen eines Zeichens: ${filename// /_} ersetzt alle Leerzeichen durch Unterstriche – ein klassisches Muster für das sichere Umbenennen von Dateien für Unix-Pfade.

Für komplexere Umbenennungsaufgaben, die Groß-/Kleinschreibung betreffen, bietet Bash 4+ die Expansionen ${var,,} (alles kleinschreiben) und ${var^^} (alles großschreiben). Das Muster ${var,} wandelt nur den ersten Buchstaben in Kleinbuchstaben um. Diese Operationen machen externe Tools wie tr für einfache Case-Konvertierungen überflüssig. Für das Massenbenennen von Dateien in Schleifen kann man die Bash-Parameterexpansion direkt in den mv-Aufruf einbetten, ohne eine temporäre Variable zu brauchen.

#!/usr/bin/env bash
# rename_patterns.sh — File renaming with Bash parameter expansion
set -euo pipefail

# Replace spaces and special characters in filenames
sanitize_names() {
  local dir="${1:-.}"
  local count=0

  while IFS= read -r -d '' file; do
    local dir_part filename new_name
    dir_part="$(dirname "$file")"
    filename="$(basename "$file")"

    # Replace spaces, parentheses, and special chars with underscores
    new_name="${filename//[[:space:]]/_}"
    new_name="${new_name//[()[\]{}]/_}"
    new_name="${new_name,,}"  # lowercase (Bash 4+)

    if [[ "$filename" != "$new_name" ]]; then
      mv -n -- "$file" "${dir_part}/${new_name}" && (( count++ )) || true
      echo "[RENAME] '$filename' -> '$new_name'"
    fi
  done < <(find "$dir" -maxdepth 1 -type f -print0)

  echo "[INFO] Renamed $count files"
}

# Change file extension: .jpeg -> .jpg
rename_extension() {
  local dir="${1:-.}"
  local from="${2:?from-extension required}"
  local to="${3:?to-extension required}"

  while IFS= read -r -d '' file; do
    local new="${file%.$from}.$to"
    [[ "$file" != "$new" ]] && mv -n -- "$file" "$new" && echo "[EXT] $file -> $new"
  done < <(find "$dir" -name "*.$from" -type f -print0)
}

# Add date prefix: report.pdf -> 2026-05-09_report.pdf
add_date_prefix() {
  local dir="${1:-.}"
  local date_prefix
  date_prefix="$(date +%Y-%m-%d)"

  while IFS= read -r -d '' file; do
    local dir_part filename
    dir_part="$(dirname "$file")"
    filename="$(basename "$file")"
    [[ "$filename" == ${date_prefix}_* ]] && continue  # already prefixed
    mv -n -- "$file" "${dir_part}/${date_prefix}_${filename}"
  done < <(find "$dir" -maxdepth 1 -type f -print0)
}

sanitize_names "${1:-.}"

3. rename für Massenbenennung mit Regex

Das Tool rename (in der Perl-Variante, verfügbar als prename oder rename.ul) erlaubt die Massenbenennung von Dateien mit vollständiger Perl-Regex-Power in einem einzigen Befehl. rename 's/\.jpeg$/.jpg/i' *.jpeg benennt alle JPEG-Dateien in einem Schritt um. rename 's/ /_/g' * ersetzt alle Leerzeichen durch Unterstriche. Das Flag -n aktiviert einen Dry-Run, der zeigt was umbenannt werden würde, ohne tatsächlich etwas zu ändern – unverzichtbar vor jeder Massenumbenennung.

Auf Debian/Ubuntu-Systemen heißt das Perl-basierte Tool rename. Auf macOS (Homebrew: brew install rename) und auf RHEL/CentOS (das dort installierte rename ist das util-linux-Tool mit anderer Syntax) kann die Version abweichen. Ein portables Skript prüft deshalb, welche Variante verfügbar ist. Für Systeme ohne Perl-rename lässt sich dasselbe mit einer find-mv-Schleife erreichen, die Bash-Parameterexpansion oder sed für die Namenstransformation nutzt. Das Umbenennen mit rename ist bei hundert oder mehr Dateien der mit Abstand komfortabelste Weg.

4. find für Sortierung nach Datum, Größe und Typ

Das find-Kommando ist das flexibelste Werkzeug zum Sortieren und Filtern von Dateien nach verschiedenen Kriterien. Mit -mtime +7 findet man alle Dateien, die seit mehr als sieben Tagen nicht geändert wurden. Mit -newer reference_file findet man alle Dateien, die jünger als eine Referenzdatei sind. Für die Sortierung nach Datum innerhalb von find ist -printf '%T@ %p\n' kombiniert mit sort -n das Standard-Pattern: Es gibt Unix-Timestamp und Pfad aus, sort -n sortiert nach Timestamp, und awk '{print $2}' extrahiert den Pfad.

Die Kombination von find mit -exec mv oder Process Substitution ermöglicht direktes Verschieben von gefundenen Dateien in neue Strukturen. Das Muster find /source -name "*.log" -mtime +30 -exec mv -t /archive {} + verschiebt alle Logdateien, die älter als 30 Tage sind, ins Archiv-Verzeichnis. Das + am Ende von -exec übergibt alle gefundenen Dateien in einem einzigen mv-Aufruf statt für jede Datei einen neuen Prozess zu starten – deutlich effizienter bei vielen Dateien.

#!/usr/bin/env bash
# organize_by_date.sh — Sort and move files into date-based directory structure
set -euo pipefail

readonly SOURCE_DIR="${1:?Usage: $0 <source-dir> <target-dir>}"
readonly TARGET_DIR="${2:?Target directory required}"
readonly DRY_RUN="${DRY_RUN:-0}"
declare -i moved=0 skipped=0

move_or_dry() {
  local src="$1" dest_dir="$2"
  if [[ "$DRY_RUN" -eq 1 ]]; then
    echo "[DRY-RUN] mv '$src' -> '${dest_dir}/'"
  else
    mkdir -p "$dest_dir"
    mv -n -- "$src" "${dest_dir}/" && (( moved++ )) || (( skipped++ ))
  fi
}

# Sort files by modification date into YYYY/MM subdirectories
while IFS= read -r -d '' file; do
  # Get modification year and month
  mod_year=$(date -r "$file" +%Y 2>/dev/null || stat -c '%y' "$file" | cut -c1-4)
  mod_month=$(date -r "$file" +%m 2>/dev/null || stat -c '%y' "$file" | cut -c6-7)
  dest="${TARGET_DIR}/${mod_year}/${mod_month}"
  move_or_dry "$file" "$dest"
done < <(find "$SOURCE_DIR" -maxdepth 1 -type f -print0)

if [[ "$DRY_RUN" -eq 0 ]]; then
  echo "[INFO] Moved: $moved, Skipped (exists): $skipped"
else
  echo "[DRY-RUN] No changes made. Set DRY_RUN=0 to execute."
fi

# Find and list the 10 largest files in a directory tree
echo "--- Top 10 largest files ---"
find "${SOURCE_DIR}" -type f -printf '%s %p\n' \
  | sort -rn \
  | head -10 \
  | awk '{ printf "%.1f MB  %s\n", $1/1024/1024, $2 }'

5. Dateien in Verzeichnisstrukturen einordnen

Das Einordnen von Dateien in Verzeichnisstrukturen ist eine häufige Automatisierungsaufgabe: Fotos nach Aufnahmedatum organisieren, Logs nach Monat archivieren, Downloads nach Dateityp sortieren. Das generische Muster besteht aus drei Schritten: Metadatum der Datei lesen (Datum, Typ, Größe), Zielverzeichnispfad berechnen und verschieben. Mit mkdir -p werden die Zielverzeichnisse bei Bedarf angelegt, ohne vorher zu prüfen, ob sie existieren. Das -p-Flag macht mkdir idempotent und verhindert Fehler, wenn das Verzeichnis bereits existiert.

Für das Sortieren von Dateien nach Typ ist file das zuverlässigste Werkzeug, weil es den Typ anhand des Dateiinhalts erkennt und nicht nur anhand der Endung. file --mime-type -b datei.jpg gibt image/jpeg zurück, unabhängig von der Dateiendung. Das erlaubt robuste Klassifizierung auch von falsch benannten Dateien. Mit case-Statements oder assoziativen Arrays lassen sich MIME-Typen auf Zielverzeichnisse mappen: image/* nach /media/bilder, video/* nach /media/videos, application/pdf nach /docs.

6. Dry-Run-Muster für sichere Massenoperationen

Das Dry-Run-Muster ist die wichtigste Sicherheitsvorkehrung beim Massenbenennen und -verschieben von Dateien. Ein Dry-Run führt das Skript komplett durch, inklusive aller Berechnungen und Validierungen, aber ersetzt alle destruktiven Operationen (mv, rm, cp) durch echo-Ausgaben. Der Operator sieht genau, was das Skript tun würde, ohne dass sich tatsächlich etwas ändert. Erst nach manueller Prüfung der Ausgabe wird das Skript mit deaktiviertem Dry-Run erneut ausgeführt.

Eine elegante Implementierung nutzt eine Shell-Funktion run_cmd(), die je nach $DRY_RUN-Variable entweder den Befehl ausführt oder ihn mit vorangestelltem [DRY-RUN] ausgibt. Alle destructiven Operationen im Skript werden über diese Funktion geleitet. So lässt sich der Dry-Run-Modus mit einer einzigen Umgebungsvariable DRY_RUN=1 ./skript.sh aktivieren, ohne den Code zu ändern. Das ist besonders wichtig bei Massenumbenennungsoperationen auf Produktionsdaten, wo ein Fehler Hunderte von Dateien betreffen kann.

7. Aufräumen: alte Dateien finden und entfernen

Das regelmäßige Aufräumen von Dateien ist eine klassische Cronjob-Aufgabe: alte Logdateien löschen, temporäre Builds aufräumen, abgelaufene Exportdateien entfernen. find mit -mtime +N (älter als N Tage), -size +N (größer als N) und -type f findet präzise die Kandidaten. Das anschließende -delete-Flag oder -exec rm entfernt sie. Entscheidend ist die Reihenfolge der Tests in find: Prüfungen, die viele Dateien ausschließen, sollten zuerst stehen, damit find die teuren Prüfungen nur für die Kandidaten durchführt, die die günstigen Tests bereits passiert haben.

Das Trash-Pattern ist eine sicherere Alternative zum direkten Löschen: Statt rm werden Dateien mit mv in ein Trash-Verzeichnis verschoben. Ein separater Cronjob leert das Trash-Verzeichnis nach einem definierten Zeitraum. So gibt es ein Zeitfenster für die manuelle Wiederherstellung, falls eine Datei versehentlich als aufräumwürdig eingestuft wurde. Das Muster ist besonders sinnvoll bei automatisierten Aufräumroutinen, die auf Basis von Regeln entscheiden, und wo die Regeln gelegentlich falsch liegen können.

#!/usr/bin/env bash
# cleanup.sh — Safe cleanup with trash pattern and reporting
set -euo pipefail

readonly LOG_DIR="${LOG_DIR:-/var/log/app}"
readonly TRASH_DIR="${TRASH_DIR:-/var/log/app/.trash}"
readonly MAX_AGE_DAYS="${MAX_AGE_DAYS:-30}"
readonly TRASH_RETENTION_DAYS="${TRASH_RETENTION_DAYS:-7}"
readonly DRY_RUN="${DRY_RUN:-0}"

declare -i moved_to_trash=0 purged=0 total_freed_bytes=0

log() { printf '%s [%s] %s\n' "$(date -u '+%Y-%m-%dT%H:%M:%SZ')" "$1" "$2" >&2; }

mkdir -p "$TRASH_DIR"

# Phase 1: Move old files to trash (soft delete)
log INFO "Phase 1: Moving files older than ${MAX_AGE_DAYS} days to trash"
while IFS= read -r -d '' file; do
  local_size=$(stat -c '%s' "$file" 2>/dev/null || echo 0)
  if [[ "$DRY_RUN" -eq 1 ]]; then
    log INFO "[DRY] Would trash: $file ($(( local_size / 1024 )) KB)"
  else
    mv -- "$file" "${TRASH_DIR}/$(date +%Y%m%d%H%M%S)_$(basename "$file")"
    (( moved_to_trash++ )) || true
    (( total_freed_bytes += local_size )) || true
  fi
done < <(find "$LOG_DIR" -maxdepth 2 -type f -name "*.log" -mtime +"$MAX_AGE_DAYS" -print0)

# Phase 2: Purge trash older than retention period (hard delete)
log INFO "Phase 2: Purging trash older than ${TRASH_RETENTION_DAYS} days"
while IFS= read -r -d '' old_trash; do
  if [[ "$DRY_RUN" -eq 1 ]]; then
    log INFO "[DRY] Would purge: $old_trash"
  else
    rm -- "$old_trash"
    (( purged++ )) || true
  fi
done < <(find "$TRASH_DIR" -maxdepth 1 -type f -mtime +"$TRASH_RETENTION_DAYS" -print0)

log INFO "Summary: moved_to_trash=$moved_to_trash, purged=$purged, freed=$(( total_freed_bytes / 1024 / 1024 ))MB"

8. Umbenennungswerkzeuge im Vergleich

Für das Umbenennen und Verschieben von Dateien in der Shell stehen mehrere Werkzeuge zur Verfügung, die sich in Mächtigkeit, Portabilität und Lernaufwand unterscheiden.

Für die tägliche Arbeit mit dem Umbenennen von Dateien in Bash ist die Kombination aus Bash-Parameterexpansion für einfache Fälle und Perl-rename für Regex-Operationen die produktivste. rsync --remove-source-files ist immer dann zu bevorzugen, wenn Dateien über Netzwerk oder Dateisystemgrenzen hinweg verschoben werden, weil es atomare Übertragung und Integritätsprüfung bietet. mv mit -n-Flag sollte in Skripten immer dann verwendet werden, wenn das Überschreiben bestehender Dateien unerwünscht ist.

9. Undo-Muster für Massendateioperationen

Das größte Risiko bei Massendateioperationen ist, dass ein Fehler in der Logik Hunderte von Dateien betrifft, bevor man den Fehler bemerkt. Das Undo-Muster adressiert dieses Risiko, indem jede durchgeführte Operation in einem Undo-Log protokolliert wird. Das Undo-Log ist eine Liste von mv-Befehlen, die die durchgeführten Verschiebe- und Umbenennungsoperationen rückgängig machen. Nach einem Massen-Umbenennen enthält das Undo-Log also alle mv neuer-name alter-name-Befehle in der richtigen Reihenfolge.

Die Implementierung ist einfach: Eine Wrapper-Funktion für mv führt die Operation durch und schreibt gleichzeitig den inversen Befehl in eine Undo-Datei. Das Undo-Skript ist dann eine Bash-Datei, die source-bar ist und die Operationen in umgekehrter Reihenfolge ausführt. Für das Aufräumen mit dem Trash-Pattern ist das Undo noch einfacher: mv trash/datei original-pfad stellt die Datei wieder her, solange sie sich noch im Trash-Verzeichnis befindet. Das Undo-Pattern macht Massendateioperationen reversibel und eliminiert die Angst vor dem Ausführen von Automatisierungsskripten auf Produktionsdaten.

#!/usr/bin/env bash
# undo_rename.sh — Mass rename with automatic undo log generation
set -euo pipefail

readonly SOURCE_DIR="${1:?Usage: $0 <directory> [pattern] [replacement]}"
readonly PATTERN="${2:-}"
readonly REPLACEMENT="${3:-}"
readonly UNDO_LOG="${SOURCE_DIR}/.undo_rename_$(date +%Y%m%d_%H%M%S).sh"
readonly DRY_RUN="${DRY_RUN:-0}"

declare -i renamed=0

# Write undo script header
cat > "$UNDO_LOG" << 'HEADER'
#!/usr/bin/env bash
# Auto-generated undo script — run to revert rename operations
set -euo pipefail
HEADER
echo "echo 'Reverting rename operations...'" >> "$UNDO_LOG"

safe_rename() {
  local old="$1" new="$2"
  [[ "$old" == "$new" ]] && return 0
  if [[ -e "$new" ]]; then
    echo "[SKIP] Target exists: $new" >&2
    return 0
  fi

  if [[ "$DRY_RUN" -eq 1 ]]; then
    echo "[DRY] mv '$old' -> '$new'"
  else
    mv -- "$old" "$new"
    # Append reverse operation to undo log (in reverse order)
    echo "mv -- '${new}' '${old}'" >> "$UNDO_LOG"
    (( renamed++ )) || true
    echo "[OK] '$old' -> '$new'"
  fi
}

# Apply pattern-based rename to all files
while IFS= read -r -d '' file; do
  dir_part="$(dirname "$file")"
  filename="$(basename "$file")"

  if [[ -n "$PATTERN" ]]; then
    new_filename="${filename//$PATTERN/$REPLACEMENT}"
  else
    # Default: sanitize spaces and lowercase
    new_filename="${filename//[[:space:]]/_}"
    new_filename="${new_filename,,}"
  fi

  safe_rename "$file" "${dir_part}/${new_filename}"
done < <(find "$SOURCE_DIR" -maxdepth 1 -type f -print0)

echo "echo 'Undo complete: $renamed operations reverted'" >> "$UNDO_LOG"
chmod +x "$UNDO_LOG"
echo "[INFO] Renamed: $renamed. Undo log: $UNDO_LOG"

10. Zusammenfassung

Das sichere Umbenennen, Verschieben, Sortieren und Aufräumen von Dateien in Bash folgt einigen klaren Grundprinzipien. mv -n verhindert unbeabsichtigtes Überschreiben. Das Dry-Run-Muster mit einer DRY_RUN-Variable macht jede Massenoperation vor der Ausführung prüfbar. Das Undo-Log protokolliert jede durchgeführte Operation als reverse mv-Befehl und macht die gesamte Operation rückgängig-machbar. Das Trash-Pattern ersetzt direktes Löschen durch Verschieben in ein Trash-Verzeichnis mit zeitverzögerter Bereinigung.

Perl-rename ist das leistungsfähigste Werkzeug für Massenbenennung mit Regex-Unterstützung und eingebautem -n-Dry-Run. Bash-Parameterexpansion reicht für einfache Fälle ohne externe Abhängigkeit. find mit -printf '%T@ %p' und sort -n sortiert Dateien nach Zeitstempel für die Einordnung in Datum-basierte Archivstrukturen. Die Kombination dieser Werkzeuge mit sorgfältiger Fehlerbehandlung ergibt Dateioperationsskripte, die auch bei Produktionsdaten vertrauenswürdig eingesetzt werden können.

11. FAQ: Dateien umbenennen, verschieben, sortieren und aufräumen