LFCA 15 🐧 Copying Files and Directories

cp copies files and directories. It reads the source, writes a new copy at the destination, and leaves the original untouched. It’s one of the commands you’ll use most often — duplicating configs before editing, backing up files, moving data into a project directory, populating a template. On the surface it’s simple: cp SOURCE DEST. Underneath there are nuances — how it handles directories, symlinks, permissions, timestamps, existing files, and the difference between copying a file into a directory versus onto a name. The LFCA exam expects you to know cp cold.

Key point: cp copies — it doesn’t move. The source stays. The destination is a new file or directory with the same content. For files, cp SOURCE DEST writes a copy. For directories, you need -r (recursive). The trailing slash on a destination directory matters: cp file dir/ copies into the directory; cp file dir overwrites the file named dir if it exists. Get the destination semantics right and cp is predictable; get them wrong and you’ll either overwrite the wrong thing or fail with a confusing error.

What `cp` does

cp reads the source and writes a new copy at the destination. The original is unchanged.

$ echo "hello" > original.txt
$ cp original.txt copy.txt
$ cat original.txt
hello
$ cat copy.txt
hello

Both files exist with the same content. The original is untouched.

What cp copies:

File contents
Permissions (usually, depending on flags)
Timestamps (only with -p)
Ownership (only with -p and root)
Extended attributes (with -a or specific flags)

What cp doesn’t do:

Doesn’t move the original — that’s mv
Doesn’t delete the source
Doesn’t create parent directories by default
Doesn’t follow or not follow symlinks the way you might expect without flags

The basic forms:

Form	Meaning
`cp file1 file2`	Copy `file1` to `file2`
`cp file1 dir/`	Copy `file1` into `dir/`
`cp file1 file2 dir/`	Copy multiple files into `dir/`
`cp -r dir1 dir2`	Copy `dir1` to `dir2` (recursive)
`cp -r dir1/ dir2/`	Copy contents of `dir1` into `dir2/`

Destination semantics: The most important thing to understand about cp.

If the destination is a directory, the source is copied into it (with the same basename)
If the destination is a name that doesn’t exist, a new file or directory is created with that name
If the destination is an existing file, cp overwrites it (unless -i or -n)

$ cp file.txt /tmp/           # copies to /tmp/file.txt
$ cp file.txt newname.txt     # copies to ./newname.txt
$ cp file.txt existing.txt    # overwrites existing.txt

Why the distinction matters: Most cp mistakes are destination mistakes — copying into the wrong place, overwriting a file you wanted to keep, or failing because the destination didn’t exist. Understanding the three cases prevents all of them.

Why cp and mv are separate: cp preserves the original; mv moves it. They’re different operations with different costs (copying is I/O-heavy; moving is a rename). Keeping them separate matches the Unix philosophy — one command, one purpose.

Copying files

The simplest case: copying one file to another.

Copy to a new name in the same directory:

$ cp report.txt report-backup.txt
$ ls
report-backup.txt  report.txt

Copy to a different directory:

$ cp report.txt /tmp/
$ ls /tmp/report.txt
/tmp/report.txt

When the destination is a directory, the file keeps its name.

Copy to a different directory with a new name:

$ cp report.txt /tmp/summary.txt
$ ls /tmp/summary.txt
/tmp/summary.txt

Copy multiple files to a directory:

$ cp file1.txt file2.txt file3.txt /tmp/
$ ls /tmp/file*.txt
/tmp/file1.txt  /tmp/file2.txt  /tmp/file3.txt

The last argument must be a directory. Each source is copied into it.

Copy with a wildcard:

$ cp *.txt /tmp/

The shell expands *.txt into multiple filenames; cp copies them all into /tmp/.

Overwriting an existing file:

$ echo "original" > dest.txt
$ cp source.txt dest.txt
$ cat dest.txt
(from source.txt)

By default, cp overwrites silently. Use -i to prompt or -n to skip.

What cp does to permissions: By default, cp creates the destination with the source’s permissions modified by the umask. To preserve exactly, use -p.

$ ls -l source.txt
-rwxr-xr-x 1 alice alice 0 Sep 22 10:30 source.txt

$ cp source.txt dest.txt
$ ls -l dest.txt
-rwxr-xr-x 1 alice alice 0 Sep 22 10:30 dest.txt

In this case permissions match because the umask doesn’t strip anything from the source. If the source has unusual permissions, cp -p is needed to preserve them exactly.

Why the umask applies: New files inherit the umask. Even when copying, the destination is a new file — the umask masks the mode. -p overrides this.

Why “copy to a directory” is the common case: You rarely copy a file to another name in the same directory. You usually copy it elsewhere — a backup directory, a temp directory, another project. The destination-is-a-directory form handles that cleanly.

`cp -i`, `-n`, `-u` — handling existing files

By default, cp overwrites existing files silently. Three flags change this.

-i — interactive:

$ cp -i source.txt dest.txt
cp: overwrite 'dest.txt'? y

Prompts before overwriting. The answer must start with y or Y to proceed.

-n — no clobber:

$ cp -n source.txt dest.txt
$ echo $?
0

Doesn’t overwrite. If the destination exists, cp silently skips it.

-u — update only:

$ cp -u source.txt dest.txt

Copies only if the source is newer than the destination, or if the destination doesn’t exist. Useful for sync-like behavior.

When to use each:

Flag	Use case
`-i`	Interactive — you want to confirm each overwrite
`-n`	Scripting — never overwrite
`-u`	Sync — only copy newer files

The alias trap: Many systems alias cp to cp -i:

$ alias cp
alias cp='cp -i'

In interactive shells, cp prompts. In scripts, aliases don’t apply — cp overwrites silently. That’s a common source of surprise: the same command behaves differently in a script.

To bypass an alias: \cp or command cp or the full path /bin/cp.

Why -i is often aliased: Accidental overwrites are a common mistake. Aliasing cp to cp -i protects against them. But it only affects interactive shells — scripts see the plain cp.

Why -n is safer in scripts: A script shouldn’t prompt — there’s no one to answer. -n makes the behavior deterministic: never overwrite. If the script needs to overwrite, it shouldn’t use -n.

Why -u exists: It’s a poor man’s sync. Copy only what’s changed. For real sync, use rsync, but cp -u covers the simple case.

Why “clobber” is the term: “Clobber” means to overwrite destructively. -n (no clobber) is the standard Unix term for “don’t overwrite.” The wording is old but consistent across tools.

Copying directories with `-r`

cp needs -r (or -R, --recursive) to copy a directory.

$ cp -r source-dir dest-dir

Without -r:

$ cp source-dir dest-dir
cp: -r not specified; omitting directory 'source-dir'

cp refuses to copy a directory unless told to recurse.

What -r does: Copies the directory and everything inside it — subdirectories, files, symlinks — recursively.

The destination rules for directories:

If the destination doesn’t exist:

$ cp -r source dest
# Creates dest/ with source's contents
# dest/source equivalent — no, dest IS the copy

The result: dest/ contains everything source/ had. source/ still exists.

If the destination exists as a directory:

$ cp -r source dest/
# Creates dest/source/ with source's contents

The source directory is copied inside dest/. Result: dest/source/.

This is the subtle part. The presence of the destination determines the behavior:

cp -r source dest (dest doesn’t exist) → dest becomes the copy of source
cp -r source dest (dest exists) → source is copied into dest, producing dest/source
cp -r source/. dest → copies the contents of source into dest, not the directory itself

Copying contents, not the directory:

$ mkdir dest
$ cp -r source/. dest/
# dest/ now contains everything inside source/
# no dest/source subdirectory

The /. at the end of the source means “the contents of this directory.” That’s the standard idiom for copying contents into an existing directory without nesting.

Examples:

$ mkdir -p a/b/c
$ touch a/b/c/file.txt

$ cp -r a copy1
$ find copy1
copy1
copy1/b
copy1/b/c
copy1/b/c/file.txt

$ mkdir existing
$ cp -r a existing
$ find existing
existing
existing/a
existing/a/b
existing/a/b/c
existing/a/b/c/file.txt

First case: dest was new, so it becomes a copy of source. Second: dest existed, so source was nested inside.

Why the difference: cp follows the same rule as with files. If the destination is a directory, the source is copied into it. If the destination is a name, the copy becomes that name. Directories aren’t special — the rule is uniform.

Why the “contents” idiom exists: Often you want to copy what’s inside a directory into another directory, not nest one inside the other. cp -r source/. dest/ says “all of source’s entries, into dest.” The /. is how you express “the contents” rather than “the directory.”

Preserving attributes with `-p` and `-a`

By default, cp creates new files with new metadata. -p preserves the important attributes; -a preserves everything.

-p — preserve:

$ cp -p source.txt dest.txt

Preserves:

Permissions (mode)
Ownership (if permitted — root only)
Timestamps (atime, mtime)
Extended attributes (on some systems)

What -p doesn’t preserve:

The inode number (always new)
Hard links (each is copied as a separate file)
SELinux contexts (in some configurations)

-a — archive:

$ cp -a source dest

-a is equivalent to -dR --preserve=all. It preserves everything -p does, plus recurses and preserves symlinks as symlinks.

What -a preserves:

Permissions, ownership, timestamps
Symlinks as symlinks (not copied as regular files)
Hard links (preserved as hard links within the copy)
Extended attributes, ACLs, SELinux contexts

When to use which:

Task	Flag
Copy config, keep perms	`-p`
Backup a directory	`-a`
Copy a project tree	`-a`
Copy a file with new timestamps	(none)

Example of timestamp preservation:

$ ls -l source.txt
-rw-r--r-- 1 alice alice 123 Jan 15 09:00 source.txt

$ cp source.txt dest.txt
$ ls -l dest.txt
-rw-r--r-- 1 alice alice 123 Sep 22 10:30 dest.txt
# (new timestamp)

$ cp -p source.txt dest2.txt
$ ls -l dest2.txt
-rw-r--r-- 1 alice alice 123 Jan 15 09:00 dest2.txt
# (original timestamp preserved)

Symlink handling: By default, cp follows symlinks — copying the target’s content. -P or -a preserves them as symlinks.

$ ln -s target.txt link.txt

$ cp link.txt copy.txt
# copy.txt is a regular file with target.txt's content

$ cp -P link.txt copy2.txt
# copy2.txt is a symlink pointing to target.txt

$ cp -a link.txt copy3.txt
# copy3.txt is a symlink (same as -P)

Why -a is called “archive”: It’s designed for backups — copy a tree with everything preserved exactly. The name comes from tar-style archiving: keep all attributes.

Why ownership preservation needs root: Only root can change file ownership. A regular user’s cp -p preserves permissions and timestamps but not owner (since the new file will be owned by the copying user). Root can preserve ownership because root can chown.

Copying symlinks

Symlinks introduce a choice: copy the link itself, or copy the target?

By default — follow (copy the target):

$ ln -s /etc/hosts mylink
$ cp mylink mycopy
$ ls -l mycopy
-rw-r--r-- 1 alice alice 234 Sep 22 10:30 mycopy

mycopy is a regular file with /etc/hosts‘s content. The symlink wasn’t copied — its target was.

With -P or -d — no dereference:

$ cp -P mylink mylinkcopy
$ ls -l mylinkcopy
lrwxrwxrwx 1 alice alice 10 Sep 22 10:30 mylinkcopy -> /etc/hosts

mylinkcopy is a symlink pointing to /etc/hosts.

With -a or -dR — same as -P:

-a implies -P and -d, so symlinks are preserved.

With -L — force follow:

$ cp -L mylink copy

-L forces following even if -P was implied by another flag.

The flags:

Flag	Behavior
(default)	Follow symlinks — copy the target
`-P`	Never follow — copy the symlink
`-L`	Always follow — copy the target
`-a`	Implies `-P` — preserve symlinks
`-d`	Same as `-P --no-dereference --preserve=links`

When each matters:

Default — you want the content, and you don’t care that the original was a symlink
-P — you want an exact replica of the tree, including symlinks
-L — you want to resolve all symlinks into regular files

Why -a preserves symlinks: It’s for backups. A backup that dereferences symlinks loses information — the restored tree wouldn’t match the original. -a keeps symlinks as symlinks.

Why -P in a project copy: A project might have symlinks (e.g., node_modules/.bin/*). Copying with -P preserves the structure. Copying with the default would dereference them, creating separate copies of the targets — often not what you want.

Why the default is “follow”: Most people copying a file want its contents, not a pointer. The symlink is usually an implementation detail. So cp follows by default. When you need the symlink itself, use -P or -a.

A full example

Using cp for common tasks.

# ============================================
# PART 1: BACKUP A FILE
# ============================================

cd ~
echo "important config" > app.conf
cp app.conf app.conf.bak
ls
# app.conf  app.conf.bak

# ============================================
# PART 2: COPY TO A DIRECTORY
# ============================================

mkdir backups
cp app.conf backups/
ls backups/
# app.conf

# ============================================
# PART 3: COPY WITH A NEW NAME
# ============================================

cp app.conf backups/app.conf.old
ls backups/
# app.conf  app.conf.old

# ============================================
# PART 4: INTERACTIVE OVERWRITE
# ============================================

cp -i app.conf backups/app.conf
# cp: overwrite 'backups/app.conf'? y

# ============================================
# PART 5: NO-CLOBBER
# ============================================

cp -n app.conf backups/app.conf
# (silent, no overwrite)

echo $?
# 0

# ============================================
# PART 6: COPY A DIRECTORY
# ============================================

mkdir -p project/src
touch project/src/main.js
touch project/README.md

cp -r project project-copy
find project-copy
# project-copy
# project-copy/README.md
# project-copy/src
# project-copy/src/main.js

# ============================================
# PART 7: COPY INTO AN EXISTING DIRECTORY
# ============================================

mkdir dest
cp -r project dest/
find dest
# dest
# dest/project
# dest/project/README.md
# dest/project/src
# dest/project/src/main.js

# ============================================
# PART 8: COPY CONTENTS ONLY
# ============================================

mkdir dest2
cp -r project/. dest2/
find dest2
# dest2
# dest2/README.md
# dest2/src
# dest2/src/main.js

# ============================================
# PART 9: PRESERVE TIMESTAMPS
# ============================================

ls -l app.conf
# -rw-r--r-- ... app.conf

sleep 2
cp -p app.conf app-preserved.conf
ls -l app-preserved.conf
# (timestamp same as app.conf)

# ============================================
# PART 10: ARCHIVE COPY
# ============================================

cp -a project project-archive
find project-archive -type f
# project-archive/README.md
# project-archive/src/main.js

# ============================================
# PART 11: COPY SYMLINKS
# ============================================

ln -s app.conf config-link

cp config-link copied-link
ls -l copied-link
# -rw-r--r-- ... copied-link (regular file)

cp -P config-link preserved-link
ls -l preserved-link
# lrwxrwxrwx ... preserved-link -> app.conf

# ============================================
# PART 12: COPY MULTIPLE FILES
# ============================================

touch file1.txt file2.txt file3.txt
mkdir txts
cp *.txt txts/
ls txts/
# file1.txt  file2.txt  file3.txt

# ============================================
# PART 13: WILDCARD WITH PATTERN
# ============================================

mkdir logs
touch logs/{access,error,debug}.log
cp logs/*.log logs-backup/ 2>/dev/null || true
mkdir logs-backup
cp logs/*.log logs-backup/
ls logs-backup/
# access.log  debug.log  error.log

Each part demonstrates a different cp use. Together they cover the practical range.

Why this session: It covers backup, directory copying, contents-only copying, timestamp preservation, symlink handling, and wildcards. These are the real tasks cp does. Once they’re familiar, cp is predictable.

Complete Example Session

# ============================================
# PART 1: BASIC FILE COPY
# ============================================

echo "content" > original.txt
cp original.txt copy.txt
cat copy.txt
# [ content ]

ls
# [ copy.txt  original.txt ]

# ============================================
# PART 2: COPY TO A DIRECTORY
# ============================================

mkdir archive
cp original.txt archive/
ls archive/
# [ original.txt ]

# ============================================
# PART 3: COPY WITH NEW NAME
# ============================================

cp original.txt archive/newname.txt
ls archive/
# [ newname.txt  original.txt ]

# ============================================
# PART 4: MULTIPLE SOURCES
# ============================================

touch a.txt b.txt c.txt
mkdir all
cp a.txt b.txt c.txt all/
ls all/
# [ a.txt  b.txt  c.txt ]

# ============================================
# PART 5: WILDCARD
# ============================================

touch more.txt
cp *.txt all/
# cp: target 'all' is not a directory? No — it is
# Actually copies all .txt files

ls all/
# [ a.txt  b.txt  c.txt  more.txt  original.txt ]

# ============================================
# PART 6: OVERWRITE DEFAULT
# ============================================

echo "old" > dest.txt
echo "new" > source.txt
cp source.txt dest.txt
cat dest.txt
# [ new ]

# ============================================
# PART 7: -i INTERACTIVE
# ============================================

cp -i source.txt dest.txt
# [ cp: overwrite 'dest.txt'? ]

# Answer n
# cat dest.txt still "new"

# ============================================
# PART 8: -n NO CLOBBER
# ============================================

cp -n source.txt dest.txt
# No prompt, no overwrite
cat dest.txt
# [ new ]

# ============================================
# PART 9: -u UPDATE
# ============================================

# Copy only if source newer
cp -u source.txt dest.txt
cat dest.txt
# [ new ]

# ============================================
# PART 10: RECURSIVE COPY
# ============================================

mkdir -p tree/sub
touch tree/file.txt tree/sub/deep.txt

cp -r tree tree-copy
find tree-copy
# [ tree-copy ]
# [ tree-copy/file.txt ]
# [ tree-copy/sub ]
# [ tree-copy/sub/deep.txt ]

# ============================================
# PART 11: NESTED VS CONTENTS
# ============================================

mkdir existing
cp -r tree existing/
ls existing/
# [ tree ]

mkdir target
cp -r tree/. target/
ls target/
# [ file.txt  sub ]

# ============================================
# PART 12: PRESERVE ATTRIBUTES
# ============================================

ls -l original.txt
# [ -rw-r--r-- 1 alice alice 8 Sep 22 10:30 original.txt ]

sleep 2

cp original.txt no-preserve.txt
ls -l no-preserve.txt
# [ -rw-r--r-- 1 alice alice 8 Sep 22 10:32 no-preserve.txt ]

cp -p original.txt preserved.txt
ls -l preserved.txt
# [ -rw-r--r-- 1 alice alice 8 Sep 22 10:30 preserved.txt ]

# ============================================
# PART 13: ARCHIVE COPY
# ============================================

cp -a tree tree-archive
diff -r tree tree-archive
# (no output — identical)

# ============================================
# PART 14: SYMLINK HANDLING
# ============================================

ln -s original.txt link.txt
ls -l link.txt
# [ lrwxrwxrwx ... link.txt -> original.txt ]

cp link.txt followed.txt
ls -l followed.txt
# [ -rw-r--r-- ... followed.txt ]
file followed.txt
# [ followed.txt: ASCII text ]

cp -P link.txt preserved-link.txt
ls -l preserved-link.txt
# [ lrwxrwxrwx ... preserved-link.txt -> original.txt ]

# ============================================
# PART 15: PRACTICAL BACKUP
# ============================================

mkdir -p ~/backups/$(date +%Y-%m-%d)
cp -a /etc/nginx ~/backups/$(date +%Y-%m-%d)/ 2>/dev/null || echo "nginx not found"

# ============================================
# PART 16: PROJECT TEMPLATE
# ============================================

mkdir -p template/{src,docs,tests}
touch template/README.md

cp -r template newproject
cd newproject
ls
# [ README.md  docs  src  tests ]

Every part exercises a cp feature. Together they cover the practical range.

Quick Reference

`cp` Syntax

Form	Meaning
`cp SRC DEST`	Copy file to file
`cp SRC DIR/`	Copy file into directory
`cp SRC1 SRC2 DIR/`	Multiple sources into directory
`cp -r DIR1 DIR2`	Copy directory recursively
`cp -r DIR/. DIR2/`	Copy contents into directory

Common Flags

Flag	Effect
`-r` / `-R`	Recursive
`-a`	Archive — preserve all, recursive
`-p`	Preserve mode, ownership, timestamps
`-i`	Interactive — prompt before overwrite
`-n`	No clobber — don’t overwrite
`-u`	Update — copy only if newer
`-v`	Verbose
`-f`	Force — remove and retry if needed
`-l`	Hard link instead of copy
`-s`	Symlink instead of copy
`-P`	No dereference — copy symlinks
`-L`	Always dereference — follow symlinks
`-d`	Same as `-P --preserve=links`
`-t DIR`	Target directory first

Flags That Imply Others

Flag	Equivalent to
`-a`	`-dR --preserve=all`
`-d`	`-P --preserve=links`
`-R`	Same as `-r`
`-H`	Follow command-line symlinks only

Destination Rules for Files

Destination	Result
Doesn’t exist	Created with source’s content
Existing file	Overwritten (unless `-i`, `-n`)
Directory	Copied inside with same basename

Destination Rules for Directories

Destination	Result
Doesn’t exist	New dir with source’s contents
Existing dir	Source nested inside
`DIR/.` source	Contents copied into destination

Symlink Behavior

Flag	Behavior
(default)	Follow — copy target
`-P`	No follow — copy symlink
`-L`	Always follow
`-a`	Implies `-P`

Preserve Options

Option	Effect
`-p`	Preserve mode, ownership, timestamps
`-a`	Preserve everything
`--preserve=mode`	Mode only
`--preserve=timestamps`	Timestamps only
`--preserve=all`	Everything

Error Messages

Message	Cause
`omitting directory`	Used `cp` without `-r` on a directory
`No such file or directory`	Source doesn’t exist
`Permission denied`	No read/write permission
`same file`	Source and destination are the same
`target is not a directory`	Multiple sources, last isn’t a directory
`cannot overwrite non-directory with directory`	Type mismatch

Common Patterns

Task	Command
Backup file	`cp file file.bak`
Copy to directory	`cp file /path/`
Copy directory	`cp -r dir1 dir2`
Copy contents	`cp -r dir1/. dir2/`
Archive copy	`cp -a src dst`
Interactive	`cp -i src dst`
No overwrite	`cp -n src dst`
Update only	`cp -u src dst`
Preserve meta	`cp -p src dst`
Multiple files	`cp file1 file2 dir/`

When to Use Which Flag

Situation	Flag
Backup everything	`-a`
One file, keep attrs	`-p`
Script safety	`-n`
Confirm each	`-i`
Sync-like	`-u`
Directory	`-r`
Preserve symlinks	`-a` or `-P`
Verbose	`-v`

Interaction with umask

Action	Effect
Default copy	umask applies
`-p`	umask ignored, source’s mode kept
`-a`	umask ignored

Verification

Command	Shows
`diff file1 file2`	Differences
`diff -r dir1 dir2`	Directory diffs
`cmp file1 file2`	Byte comparison
`ls -l`	File details
`md5sum file`	Hash for equality

Best Practices

✅ Do This:

# Use -i for interactive safety
cp -i source dest                                       # ✅

# Use -n in scripts to avoid overwrites
cp -n source dest                                       # ✅

# Use -r for directories
cp -r src-dir dest-dir                                  # ✅

# Preserve timestamps for backups
cp -p important.conf important.conf.bak                 # ✅

# Use -a for full backups
cp -a project/ backup/                                  # ✅

# Copy contents, not the directory
cp -r source/. destination/                             # ✅

# Verify after copying
diff -r source/ destination/                            # ✅

# Use -v in scripts that log
cp -v source dest                                       # ✅

# Quote paths with spaces
cp "My File.txt" "My File Copy.txt"                     # ✅

# Use $(date) for timestamped backups
cp app.conf app.conf.$(date +%Y%m%d)                    # ✅

❌ Don’t Do This:

# Don't forget -r for directories
cp source-dir dest                                      # ❌

# Don't overwrite silently in scripts
cp source dest  # overwrites without warning           # ⚠️

# Don't assume the destination is what you think
cp file.txt /tmp  # is /tmp a dir? yes                   # ✅
# But:
cp file.txt /tmp  # if /tmp is a file → copies over it  # ⚠️

# Don't rely on umask for protection
cp secret.txt public/  # umask may not be enough        # ⚠️

# Don't use cp for symlinks without -P
cp -r tree copy  # loses symlinks                        # ⚠️

# Don't create content with cp
cp empty.txt file  # both empty                          # ⚠️

# Don't use cp to move large files
cp bigfile bigcopy && rm bigfile  # use mv instead       # ⚠️

# Don't skip the trailing slash meaning
cp -r src dest/   # nests source inside dest             # ⚠️
cp -r src/. dest/ # contents only                        # ✅

# Don't ignore errors
cp -r dir dest 2>/dev/null  # silent failure             # ⚠️

# Don't copy to a path without permissions
cp file /root/  # permission denied for non-root         # ⚠️

Common Pitfalls

Pitfall	Problem	Solution
Missing `-r`	Directory copy fails	Add `-r`
`cp dir dest` nests	Unexpected structure	Use `dir/.`
Overwrites silently	Lost file	Use `-i` or `-n`
Alias not in script	Different behavior	Use full path
`cp -p` as non-root	Ownership not preserved	Expected
`cp` follows symlinks	Regular file created	Use `-P`
Umask modifies perms	Different from source	Use `-p`
Multiple sources	Last isn’t dir	Fix order
Source is dir, no `-r`	Error	Add `-r`
Destination same as source	`same file` error	Different name

Real-World Examples

1. Backup a file

cp config.ini config.ini.bak

2. Backup with date

cp config.ini config.ini.$(date +%Y%m%d)

3. Copy to directory

cp report.pdf ~/Documents/

4. Copy with new name

cp original.txt renamed.txt

5. Copy multiple files

cp *.log /var/log/archive/

6. Interactive overwrite

cp -i file1.txt file2.txt

7. No-overwrite copy

cp -n source.txt dest.txt

8. Update-only copy

cp -u /src/* /dest/

9. Copy a directory

cp -r projects projects-backup

10. Copy contents

cp -r template/. myproject/

11. Preserve timestamps

cp -p original.txt preserved.txt

12. Archive copy

cp -a /etc/nginx /backups/nginx-$(date +%F)

13. Copy with symlinks preserved

cp -a node_modules /tmp/nm-backup

14. Verbose copy

cp -rv source-dir dest-dir

15. Force overwrite

cp -f source dest

16. Hard link instead

cp -l original hardlink

17. Symlink instead

cp -s /path/to/file symlink-name

18. Copy a project skeleton

cp -r ~/templates/webapp ./newapp

19. Copy dotfiles

cp -a ~/.config/.* /backup/config/

20. Verify a copy

diff -r source-dir dest-dir

Visual: `cp` Basics

┌──────────────────────────────────────────────┐
│  source.txt                                  │
│  ─ content: "hello"                          │
│  ─ permissions: rw-r--r--                    │
│                                              │
└──────────────────────────────────────────────┘
                  │
                  │  cp source.txt dest.txt
                  ▼
┌──────────────────────────────────────────────┐
│  source.txt (unchanged)                      │
│  dest.txt (new, identical content)           │
│                                              │
│  Both exist now                              │
│                                              │
└──────────────────────────────────────────────┘

Visual: Destination Semantics

┌──────────────────────────────────────────────┐
│  cp file.txt newname.txt                     │
│                                              │
│  → file.txt copied to ./newname.txt          │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  cp file.txt /tmp/                           │
│                                              │
│  → file.txt copied to /tmp/file.txt          │
│  → destination is a directory                │
│  → source basename is kept                   │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  cp file.txt existing-file.txt               │
│                                              │
│  → existing-file.txt overwritten             │
│  → unless -i or -n                           │
│                                              │
└──────────────────────────────────────────────┘

Visual: Directory Copy Behavior

┌──────────────────────────────────────────────┐
│  Case 1: Destination doesn't exist           │
│                                              │
│  $ cp -r source dest                         │
│                                              │
│  source/ ──► becomes dest/                   │
│                                              │
│  dest/                                       │
│  ├── (source's contents)                     │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  Case 2: Destination exists as a directory   │
│                                              │
│  $ cp -r source existing/                    │
│                                              │
│  source/ ──► nested inside existing/         │
│                                              │
│  existing/                                   │
│  └── source/                                 │
│      ├── (source's contents)                 │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  Case 3: Copy contents only                  │
│                                              │
│  $ cp -r source/. existing/                  │
│                                              │
│  source's contents → existing/               │
│                                              │
│  existing/                                   │
│  ├── (source's files)                        │
│                                              │
└──────────────────────────────────────────────┘

Visual: Preserve Attributes

┌──────────────────────────────────────────────┐
│  $ cp source.txt dest.txt                    │
│                                              │
│  source.txt:                                 │
│    mode: 755                                 │
│    mtime: Jan 15 09:00                       │
│                                              │
│  dest.txt (default cp):                      │
│    mode: 755 (from umask? kept)              │
│    mtime: now ← updated                      │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  $ cp -p source.txt dest.txt                 │
│                                              │
│  dest.txt:                                   │
│    mode: 755 (exact)                         │
│    mtime: Jan 15 09:00 (preserved)           │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  $ cp -a source-dir dest-dir                 │
│                                              │
│  All of:                                     │
│    permissions ✅                            │
│    ownership (root) ✅                       │
│    timestamps ✅                             │
│    symlinks as symlinks ✅                   │
│    hard links ✅                             │
│                                              │
└──────────────────────────────────────────────┘

Visual: Symlink Behavior

┌──────────────────────────────────────────────┐
│  source-dir/                                 │
│  ├── file.txt                                │
│  └── link.txt → file.txt                     │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  cp -r source-dir dest                       │
│                                              │
│  dest/                                       │
│  ├── file.txt                                │
│  └── link.txt   ← regular file (target copy) │
│                                              │
│  (default follows symlinks)                  │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  cp -a source-dir dest                       │
│                                              │
│  dest/                                       │
│  ├── file.txt                                │
│  └── link.txt → file.txt                     │
│                                              │
│  (symlink preserved)                         │
│                                              │
└──────────────────────────────────────────────┘

Visual: `-i` vs `-n` vs `-u`

┌──────────────────────────────────────────────┐
│  Default: silent overwrite                   │
│                                              │
│  $ cp src dst                                │
│  (dst overwritten)                           │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  -i: interactive                             │
│                                              │
│  $ cp -i src dst                             │
│  cp: overwrite 'dst'? _                      │
│                                              │
│  y → overwrite                               │
│  n → skip                                    │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  -n: no clobber                              │
│                                              │
│  $ cp -n src dst                             │
│  (dst not overwritten)                       │
│                                              │
│  Silent skip — no prompt                     │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  -u: update only                             │
│                                              │
│  $ cp -u src dst                             │
│  ─ If src newer than dst → overwrite         │
│  ─ If dst newer or same → skip               │
│  ─ If dst missing → copy                     │
│                                              │
└──────────────────────────────────────────────┘

Visual: Common Backup Workflow

┌──────────────────────────────────────────────┐
│  Before editing a config:                    │
│                                              │
│  1. cp /etc/nginx/nginx.conf \               │
│        /etc/nginx/nginx.conf.bak             │
│                                              │
│  2. (edit /etc/nginx/nginx.conf)             │
│                                              │
│  3. If problems:                             │
│     cp /etc/nginx/nginx.conf.bak \           │
│        /etc/nginx/nginx.conf                 │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  Before upgrading a directory:               │
│                                              │
│  1. cp -a project project-$(date +%F)        │
│                                              │
│  2. (upgrade project)                        │
│                                              │
│  3. If problems:                             │
│     rm -rf project                           │
│     mv project-$(date +%F) project           │
│                                              │
└──────────────────────────────────────────────┘

Visual: `cp` vs `mv`

┌──────────────────────────────────────────────┐
│  cp source dest                              │
│                                              │
│  source → still exists                       │
│  dest → new copy                             │
│                                              │
│  Reads + writes data                         │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  mv source dest                              │
│                                              │
│  source → gone                               │
│  dest → same inode (if same filesystem)      │
│                                              │
│  Renames — fast if same fs                   │
│                                              │
└──────────────────────────────────────────────┘

Visual: Path Forms

┌──────────────────────────────────────────────┐
│  cp /etc/hosts /tmp/hosts-copy               │
│       absolute    absolute                   │
│                                              │
│  cp hosts /tmp/                              │
│       relative    absolute                   │
│                                              │
│  cp ~/notes.txt .                            │
│       from home    to current                │
│                                              │
│  cp ../other/file.txt ./file.txt             │
│       from parent   to current               │
│                                              │
└──────────────────────────────────────────────┘

Visual: Decision Flow

┌──────────────────────────────────────────────┐
│  Copying a file?                             │
│       │                                      │
│       └── cp SRC DEST                        │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  Copying a directory?                        │
│       │                                      │
│       └── cp -r SRC DEST                     │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  Want to preserve everything?                │
│       │                                      │
│       └── cp -a SRC DEST                     │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  Worried about overwriting?                  │
│       │                                      │
│       ├── Interactive ──► -i                 │
│       ├── Never ──► -n                       │
│       └── Only if newer ──► -u               │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  Copying contents, not the directory?        │
│       │                                      │
│       └── cp -r src/. dest/                  │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│  Preserve symlinks?                          │
│       │                                      │
│       └── cp -a or cp -P                     │
│                                              │
└──────────────────────────────────────────────┘

Summary

Command	Purpose
`cp SRC DEST`	Copy file to file
`cp SRC DIR/`	Copy file into directory
`cp -r DIR1 DIR2`	Copy directory
`cp -r DIR/. DIR2/`	Copy contents only
`cp -a SRC DEST`	Archive copy
`cp -p SRC DEST`	Preserve attributes
`cp -i SRC DEST`	Interactive overwrite
`cp -n SRC DEST`	Never overwrite
`cp -u SRC DEST`	Copy only if newer
`cp -P SRC DEST`	Copy symlinks as symlinks

Key takeaways:

cp copies — the source stays, the destination is new
Destination is a directory → source copied into it, keeping the basename
Destination is a name → the copy becomes that name; existing files are overwritten
-r is required for directories — no exceptions
cp -r src dest nests differently depending on whether dest exists
cp -r src/. dest/ copies contents, not the directory itself
-i prompts before overwrite; -n never overwrites; -u copies only if newer
-p preserves permissions, ownership, and timestamps
-a is -p plus recursive plus symlink preservation — the backup flag
Default behavior follows symlinks — use -P or -a to preserve them
umask applies to new files unless -p or -a is used
Aliases only affect interactive shells — scripts see plain cp
Verify with diff -r source dest

Remember: cp is the copy command — source stays, destination is new. It’s simple for files, careful for directories, and full of subtle flags for edge cases. Know the destination semantics (into vs onto), use -r for directories, -a for backups, -i or -n to prevent overwrites, and -p when timestamps matter. Get those right and cp becomes one of the most reliable tools in your kit. Nearly every workflow starts by copying something — a config for backup, a template for a new project, a file into a directory. That’s what cp is for.

Stop using slow, ad-bloated tool sites! 🤮

🔎 Search “KandZ Tools” on Google to use many professional utilities for free.

KandZ.me is the ultimate minimalist hub for:
✅ Finance (Mortgage, Interest, Inflation)
✅ Tech (Base64, JSON, Dev Suite, IP)
✅ Health (BMI, BMR, TDEE)
✅ Productivity (Timer, Workspace, QR)

⚡️ Fast & Private
🔒 No data leaves your device
💎 100% Free

🔗 Use it now: https://tools.kandz.me
🔖 Bookmark it—you’ll need it later!

What cp does