# cp — Dateien und Verzeichnisse kopieren

> Praxis-Guide zu cp: Dateien und Verzeichnisse kopieren, Attribute erhalten, Überschreiben kontrollieren und schnelle Reflink-Kopien nutzen.

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

<!-- PROSE:intro -->
`cp` (copy) gehört zu den grundlegendsten Unix-Kommandos: Es dupliziert Dateien und Verzeichnisse, legt Backups an und verteilt Inhalte über das Dateisystem. Im Alltag brauchst du es, um eine Konfigurationsdatei vor dem Bearbeiten zu sichern, ein Projektverzeichnis rekursiv mit `-r` zu kopieren oder mit `-a` einen exakten Klon samt Rechten, Eigentümer und Zeitstempeln zu erstellen. Ein wichtiger Stolperstein: Ohne `-i` überschreibt `cp` vorhandene Zieldateien kommentarlos – greife im Zweifel zu `-i` (nachfragen), `-n` (nie überschreiben) oder `-b` (Backup anlegen). Auf modernen Dateisystemen wie Btrfs oder XFS macht `--reflink` Kopien sogar praktisch verzögerungsfrei.
<!-- PROSE:intro:end -->

## Grundlegendes Kopieren

`cp <source> <destination>` — Kopiert eine Datei an einen neuen Ort oder unter neuem Namen.

```bash
cp config.yml config-backup.yml
```

`cp <file1> <file2> <directory>` — Kopiert mehrere Dateien in ein Verzeichnis.

```bash
cp index.html style.css app.js /var/www/html/
```

`cp <source> <directory>/` — Kopiert eine Datei in ein Verzeichnis und behält den Originalnamen bei.

```bash
cp report.pdf /tmp/
```

`cp *.txt <directory>` — Kopiert alle Dateien, die auf ein Glob-Muster passen, in ein Verzeichnis.

```bash
cp *.jpg /backup/photos/
```

## Verzeichnisse kopieren

`cp -r <source_dir> <destination_dir>` — Kopiert ein Verzeichnis rekursiv samt allem Inhalt.

```bash
cp -r ./project/ /backup/project/
```

`cp -R <source_dir> <destination_dir>` — Synonym für -r. Kopiert Verzeichnisse rekursiv.

```bash
cp -R ./src/ /backup/src/
```

`cp -r <source_dir>/ <destination_dir>/` — Kopiert den Inhalt eines Verzeichnisses in ein anderes Verzeichnis.

```bash
cp -r ./dist/ /var/www/html/
```

`cp -r <dir1> <dir2> <dir3> <target_dir>` — Kopiert mehrere Verzeichnisse in ein Zielverzeichnis.

```bash
cp -r ./css ./js ./images /var/www/html/
```

## Attribute erhalten

`cp -p <source> <destination>` — Erhält Dateirechte, Eigentümer und Zeitstempel.

```bash
cp -p script.sh /usr/local/bin/
```

`cp -a <source> <destination>` — Archivmodus. Wie -dR --preserve=all. Erhält alles, einschließlich Symlinks.

```bash
cp -a /var/www/html/ /backup/www/
```

`cp --preserve=mode,timestamps <source> <destination>` — Erhält nur bestimmte Attribute.

```bash
cp --preserve=mode,timestamps deploy.sh /usr/local/bin/
```

`cp --preserve=all <source> <destination>` — Erhält alle Attribute: Rechte, Eigentümer, Zeitstempel, Kontext, Links, xattr.

```bash
cp --preserve=all important.conf /etc/app/
```

`cp --no-preserve=ownership <source> <destination>` — Kopiert, erhält aber ausdrücklich nicht den Eigentümer.

```bash
cp --no-preserve=ownership /root/config.yml /home/user/
```

## Überschreiben steuern

`cp -i <source> <destination>` — Interaktiver Modus. Fragt nach, bevor eine vorhandene Datei überschrieben wird.

```bash
cp -i new-config.yml /etc/app/config.yml
```

`cp -n <source> <destination>` — No-Clobber. Überschreibt niemals eine vorhandene Datei.

```bash
cp -n defaults.conf /etc/app/config.conf
```

`cp -f <source> <destination>` — Erzwingen. Entfernt die Zieldatei, falls sie sich nicht öffnen lässt, und kopiert dann.

```bash
cp -f updated.bin /usr/local/bin/app
```

`cp -u <source> <destination>` — Aktualisieren. Kopiert nur, wenn die Quelle neuer als das Ziel oder das Ziel nicht vorhanden ist.

```bash
cp -u *.html /var/www/html/
```

`cp --update=none <source> <destination>` — Expliziter Aktualisierungsmodus: none (wie -n), all (Standard) oder older (wie -u).

```bash
cp --update=older ./assets/* /var/www/assets/
```

## Symlinks & Spezialdateien

`cp -d <source> <destination>` — Kopiert symbolische Links als Links, nicht die Dateien, auf die sie zeigen.

```bash
cp -d current-release /backup/current-release
```

`cp -L <source> <destination>` — Folgt symbolischen Links immer. Kopiert die Datei, auf die der Symlink zeigt.

```bash
cp -L /etc/alternatives/editor ./editor-backup
```

`cp -P <source> <destination>` — Folgt symbolischen Links nie. Kopiert den Symlink selbst (Standard bei -r).

```bash
cp -P link.txt /backup/
```

`cp -s <source> <destination>` — Erstellt einen symbolischen Link, statt die Datei zu kopieren.

```bash
cp -s /opt/app/config.yml /etc/app/config.yml
```

`cp -l <source> <destination>` — Erstellt einen Hardlink, statt zu kopieren. Spart Speicherplatz.

```bash
cp -l large-file.iso /backup/large-file.iso
```

## Ausgabe & Rückmeldung

`cp -v <source> <destination>` — Ausführlicher Modus. Gibt jede Datei aus, während sie kopiert wird.

```bash
cp -v *.conf /etc/app/
```

`cp -rv <source_dir> <destination_dir>` — Kopiert rekursiv mit ausführlicher Ausgabe. Zeigt jede kopierte Datei an.

```bash
cp -rv ./project/ /backup/project/
```

`cp -v --backup=numbered <source> <destination>` — Erstellt nummerierte Backups vorhandener Dateien und zeigt die Ausgabe an.

```bash
cp -v --backup=numbered config.yml /etc/app/config.yml
```

## Backup-Optionen

`cp -b <source> <destination>` — Erstellt vor dem Überschreiben ein Backup der Zieldatei (hängt das Suffix ~ an).

```bash
cp -b new.conf /etc/app/app.conf
```

`cp --backup=numbered <source> <destination>` — Erstellt nummerierte Backups (.~1~, .~2~ usw.) statt eines einzelnen ~-Backups.

```bash
cp --backup=numbered config.yml /etc/app/config.yml
```

`cp --backup=existing <source> <destination>` — Nutzt nummerierte Backups, falls bereits welche existieren, sonst ein einfaches ~-Backup.

```bash
cp --backup=existing data.json /var/data/data.json
```

`cp -S '<suffix>' <source> <destination>` — Nutzt ein eigenes Suffix für Backup-Dateien statt des Standards ~.

```bash
cp -b -S '.bak' config.yml /etc/app/config.yml
```

## Sparse-Dateien & Performance

`cp --sparse=auto <source> <destination>` — Erkennt Sparse-Dateien automatisch und erhält sie (Standardverhalten).

```bash
cp --sparse=auto disk.img /backup/
```

`cp --sparse=always <source> <destination>` — Versucht immer, Sparse-Dateien zu erzeugen. Nützlich für Festplatten- und virtuelle Images.

```bash
cp --sparse=always vm-disk.qcow2 /backup/
```

`cp --reflink=auto <source> <destination>` — Nutzt Copy-on-Write, falls das Dateisystem es unterstützt (Btrfs, XFS). Verzögerungsfreie Kopien.

```bash
cp --reflink=auto large-file.tar /backup/
```

`cp --reflink=always <source> <destination>` — Erzwingt Copy-on-Write. Schlägt fehl, wenn das Dateisystem es nicht unterstützt.

```bash
cp --reflink=always database.db /snapshot/
```

## Zielverzeichnis & Struktur

`cp -t <directory> <file1> <file2>` — Gibt zuerst das Zielverzeichnis an. Nützlich mit xargs und find.

```bash
find . -name '*.log' -print0 | xargs -0 cp -t /backup/logs/
```

`cp -T <source> <destination>` — Behandelt das Ziel als normale Datei, nicht als Verzeichnis. Schlägt fehl, wenn das Ziel ein Verzeichnis ist.

```bash
cp -T config-new.yml config.yml
```

`cp --parents <source> <destination>` — Erhält die vollständige Quellpfad-Struktur unterhalb des Zielverzeichnisses.

```bash
cp --parents src/app/main.js /backup/
```

## Häufige Muster

`cp -a <source>/ <destination>/` — Spiegelt einen Verzeichnisbaum unter Erhalt aller Attribute. Ideal für lokale Backups.

```bash
cp -a /var/www/html/ /backup/www/
```

`cp -rn <source>/ <destination>/` — Kopiert nur neue Dateien, überspringt vorhandene. Nützlich für inkrementelles Zusammenführen.

```bash
cp -rn ./new-assets/ /var/www/assets/
```

`cp -ru <source>/ <destination>/` — Kopiert rekursiv nur neuere oder fehlende Dateien.

```bash
cp -ru ./updated-site/ /var/www/html/
```

`cp -av <source>/ <destination>/` — Archivkopie mit ausführlicher Ausgabe. Zeigt genau, was kopiert wird.

```bash
cp -av /home/user/ /backup/user/
```

`cp /dev/null <file>` — Setzt eine Datei auf null Bytes zurück (leert sie), ohne sie zu löschen.

```bash
cp /dev/null /var/log/app.log
```

`find <dir> -name '<pattern>' -exec cp {} <dest>/ \;` — Findet Dateien nach Muster und kopiert sie in ein einzelnes Zielverzeichnis.

```bash
find ./project/ -name '*.pdf' -exec cp {} /backup/pdfs/ \;
```

`find <dir> -name '<pattern>' -print0 | xargs -0 cp -t <dest>/` — Findet und kopiert Dateien sicher (kommt mit Leerzeichen in Dateinamen zurecht).

```bash
find ./docs/ -name '*.md' -print0 | xargs -0 cp -t /backup/docs/
```

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

`cp` ist das Arbeitspferd zum Duplizieren von Dateien: Für den Alltag reichen `cp <quelle> <ziel>`, `cp -r` für Verzeichnisse und `cp -a` für exakte Spiegelungen mit allen Attributen. Behalte im Kopf, dass `cp` ohne `-i` vorhandene Zieldateien stillschweigend überschreibt – beim Hantieren mit wichtigen Daten lohnt sich `-i`, `-n` oder `-b`. Erst kopieren, dann das Original verändern ist eine gute Gewohnheit. Auf Copy-on-Write-Dateisystemen sparst du mit `--reflink=auto` Zeit und Platz, und für große, lokale Backups ist `cp -a` meist die richtige Wahl.

## Weiterführende Links

- [GNU Coreutils: cp](https://www.gnu.org/software/coreutils/manual/html_node/cp-invocation.html) – offizielle Referenz zu allen Optionen (englisch)
- [ubuntuusers-Wiki: cp](https://wiki.ubuntuusers.de/cp/) – deutschsprachige Einführung mit Praxisbeispielen
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [mv](https://www.jpkc.com/db/cheatsheets/files-text/mv/) – Dateien verschieben oder umbenennen, statt eine Kopie anzulegen
- [rm](https://www.jpkc.com/db/cheatsheets/files-text/rm/) – Dateien und Verzeichnisse löschen
- [ln](https://www.jpkc.com/db/cheatsheets/files-text/ln/) – Hard- und symbolische Links erstellen statt zu kopieren