RED HAT ENTERPRISE LINUX

File Management

Copy, Move, Create, Delete, and Organize

CIS126RH | RHEL System Administration 1
Mesa Community College

Learning Objectives

Create files and directories

Use touch, mkdir, and other methods to create new items

Copy files and directories

Duplicate files with cp, preserving attributes when needed

Move and rename files

Relocate and rename with mv command

Delete files and directories safely

Remove items with rm and rmdir, understanding the risks

Organize with wildcards and patterns

Use globbing to work with multiple files efficiently

We have five main learning objectives. First, you will create files and directories using commands like touch and mkdir, learning different ways to create empty files and nested directory structures. Second, you will copy files and directories with the cp command, understanding how to duplicate individual files, entire directories, and preserve file attributes. Third, you will move and rename files using mv, which handles both relocating files to different directories and changing their names. Fourth, you will delete files and directories safely with rm and rmdir, understanding the permanent nature of deletion in Linux and how to protect yourself from accidents. Fifth, you will organize files efficiently using wildcards and globbing patterns, allowing you to work with many files at once based on name patterns.

Paths: Absolute vs Relative

Before managing files, understand how to specify their locations. Paths can be absolute (from root) or relative (from current directory).

# Absolute paths start from root (/)
[user@host ~]$ cat /etc/hostname
[user@host ~]$ ls /var/log/messages

# Relative paths start from current directory
[user@host ~]$ pwd
/home/student
[user@host ~]$ cat Documents/notes.txt    # Relative to /home/student

# Special path symbols
.     Current directory
..    Parent directory
~     Home directory (/home/username)
~bob  Bob's home directory (/home/bob)

# Examples using special symbols
[user@host Documents]$ ls ../Downloads    # Parent's Downloads
[user@host /var/log]$ cp messages ~/       # Copy to home

Before diving into file operations, let us review paths - how we specify file locations. Absolute paths start from the root directory, indicated by a leading slash. They work the same regardless of your current location. /etc/hostname means the hostname file in the etc directory directly under root. Relative paths start from your current directory and do not begin with a slash. If you are in /home/student, then Documents/notes.txt means /home/student/Documents/notes.txt. Special symbols make paths more convenient. A single dot represents the current directory - often used to be explicit. Two dots represent the parent directory - useful for going up one level. The tilde represents your home directory, and tilde followed by a username represents that user's home. These symbols work in any command that takes paths. You will use them constantly, so make sure you are comfortable with the concept.

Creating Files: touch

touch creates empty files or updates timestamps on existing files. It is the simplest way to create a new, empty file.

# Create a single empty file
[user@host ~]$ touch newfile.txt
[user@host ~]$ ls -l newfile.txt
-rw-r--r--. 1 student student 0 Jan 20 10:00 newfile.txt

# Create multiple files at once
[user@host ~]$ touch file1.txt file2.txt file3.txt

# Create file in specific directory
[user@host ~]$ touch Documents/report.txt

# If file exists, touch updates its timestamp
[user@host ~]$ ls -l oldfile.txt
-rw-r--r--. 1 student student 100 Jan 15 08:00 oldfile.txt
[user@host ~]$ touch oldfile.txt
[user@host ~]$ ls -l oldfile.txt
-rw-r--r--. 1 student student 100 Jan 20 10:05 oldfile.txt

Note: touch creates files with zero bytes. The file exists but contains nothing. Use editors or redirection to add content.

The touch command is the simplest way to create an empty file. Just type touch followed by the filename. The file is created with zero bytes - it exists but contains nothing. You can create multiple files in one command by listing them all after touch. You can also specify paths to create files in other directories. If the file already exists, touch does not modify its contents. Instead, it updates the file's timestamp to the current time. This behavior is useful for various purposes - marking files as recently accessed, or triggering systems that watch for timestamp changes. Files created with touch inherit default permissions based on your umask setting. The owner is you, and the group is your primary group. Touch is great for creating placeholder files or testing, but to create files with actual content, you will use text editors or output redirection.

Creating Directories: mkdir

mkdir (make directory) creates new directories. Use -p to create parent directories as needed.

# Create a single directory
[user@host ~]$ mkdir projects
[user@host ~]$ ls -ld projects
drwxr-xr-x. 2 student student 4096 Jan 20 10:00 projects

# Create multiple directories
[user@host ~]$ mkdir dir1 dir2 dir3

# Create nested directories - fails without parent
[user@host ~]$ mkdir projects/web/frontend
mkdir: cannot create directory 'projects/web/frontend': No such file or directory

# Use -p to create parent directories automatically
[user@host ~]$ mkdir -p projects/web/frontend
[user@host ~]$ mkdir -p projects/web/backend
[user@host ~]$ mkdir -p projects/mobile/{ios,android}

# Verify with tree (if installed) or ls -R
[user@host ~]$ ls -R projects
projects:
mobile  web

projects/mobile:
android  ios

projects/web:
backend  frontend

The mkdir command creates directories. By itself, mkdir creates a single directory in your current location or at a specified path. You can create multiple directories by listing them after the command. However, mkdir by default only creates the final directory in a path. If you try to create projects/web/frontend but projects/web does not exist, it fails. The -p option solves this. It creates parent directories as needed. mkdir -p projects/web/frontend creates projects, then web inside it, then frontend - all in one command. The -p option also does not complain if directories already exist, making it safe to use in scripts. The curly brace expansion shown - {ios,android} - is a shell feature that expands to multiple items. mkdir -p projects/mobile/{ios,android} creates both ios and android directories in one command. This is efficient for setting up project structures. Use ls -R for recursive listing to verify nested directory structures, or the tree command if it is installed.

Other Ways to Create Files

# Redirect output to create file with content
[user@host ~]$ echo "Hello World" > greeting.txt
[user@host ~]$ cat greeting.txt
Hello World

# Append to file (creates if doesn't exist)
[user@host ~]$ echo "Another line" >> greeting.txt

# Create empty file with redirection
[user@host ~]$ > emptyfile.txt

# Use cat with heredoc for multi-line content
[user@host ~]$ cat > notes.txt << EOF
Line 1
Line 2
Line 3
EOF

# Copy from another file
[user@host ~]$ cp /etc/hostname myhostname.txt

# Use text editors (creates on save)
[user@host ~]$ vim newdocument.txt
[user@host ~]$ nano newdocument.txt

Tip: > overwrites existing content. >> appends. Be careful with > on important files!

Beyond touch, there are several ways to create files. Output redirection with the greater-than symbol creates a file and writes command output to it. echo "Hello" > file.txt creates file.txt with "Hello" as its content. If the file exists, this overwrites it. Double greater-than appends instead of overwriting. echo "more" >> file.txt adds to the end of an existing file. If the file does not exist, it creates it. A bare redirection > emptyfile.txt creates an empty file - similar to touch but slightly different in behavior. The heredoc syntax with cat lets you create multi-line files interactively. Everything between << EOF and EOF goes into the file. Copying an existing file is another way to create a file with content. Text editors like vim or nano create files when you save - if you open a non-existent file and save, it creates the file. Choose your method based on whether you need empty files, files with simple content, or files requiring editing.

Copying Files: cp Basics

cp (copy) duplicates files and directories. The original remains unchanged; a new copy is created.

cp [options] source destination

# Copy file to new name (same directory)
[user@host ~]$ cp report.txt report_backup.txt

# Copy file to different directory (keeps name)
[user@host ~]$ cp report.txt Documents/

# Copy file to different directory with new name
[user@host ~]$ cp report.txt Documents/quarterly_report.txt

# Copy multiple files to a directory
[user@host ~]$ cp file1.txt file2.txt file3.txt Documents/

# Warning: copying to existing file overwrites silently!
[user@host ~]$ cp newdata.txt olddata.txt   # olddata.txt is replaced!

# Use -i for interactive (prompts before overwrite)
[user@host ~]$ cp -i newdata.txt olddata.txt
cp: overwrite 'olddata.txt'? y

The cp command copies files. The basic syntax is cp source destination. The source file remains unchanged; a new copy is created at the destination. When copying to a directory, include the trailing slash or just the directory name - cp report.txt Documents/ copies report.txt into the Documents directory, keeping its original name. To copy with a new name, specify the full destination path including the new filename. You can copy multiple files to a directory by listing all source files followed by the destination directory. A critical warning: by default, cp overwrites existing files without asking. If olddata.txt exists and you cp newdata.txt olddata.txt, the old content is gone. The -i option makes cp interactive - it asks before overwriting. Some administrators alias cp to cp -i in their shell configuration for safety. Always be aware of what exists at your destination.

Copying Directories

# Copying a directory requires -r (recursive)
[user@host ~]$ cp projects backup_projects
cp: -r not specified; omitting directory 'projects'

# Use -r to copy directory and all contents
[user@host ~]$ cp -r projects backup_projects

# Copy directory into another directory
[user@host ~]$ cp -r projects /tmp/
# Result: /tmp/projects/...

# Common options for directory copying
[user@host ~]$ cp -rv projects backup_projects    # verbose output
'projects' -> 'backup_projects'
'projects/file1.txt' -> 'backup_projects/file1.txt'
...

# Preserve permissions, ownership, timestamps
[user@host ~]$ cp -rp projects backup_projects

# Archive mode (-a): preserve everything, recursive
[root@host ~]# cp -a /etc /backup/etc_backup

Important: Without -r, cp silently skips directories. Always use -r for directory copies.

Copying directories requires the -r (recursive) option. Without it, cp skips directories entirely, which can be confusing - you think you copied something but you did not. The -r option means copy the directory and everything inside it - all files, subdirectories, and their contents, recursively. The -v option (verbose) shows each file being copied. Helpful for large copies so you can see progress and verify what is happening. The -p option preserves file attributes - permissions, ownership, and timestamps. Without it, copied files get new timestamps and may have different permissions. The -a option (archive) combines -r with preservation of everything possible. It is the standard choice for making true backups or copies where you want an exact replica. As root, cp -a preserves ownership. As a regular user, you cannot change ownership, so files will be owned by you regardless.

Moving and Renaming: mv

mv (move) relocates files and directories. It also serves as the rename command - moving to the same directory with a new name.

mv [options] source destination

# Rename a file (move to same directory, different name)
[user@host ~]$ mv oldname.txt newname.txt

# Move file to different directory
[user@host ~]$ mv report.txt Documents/

# Move and rename simultaneously
[user@host ~]$ mv draft.txt Documents/final_report.txt

# Move multiple files to directory
[user@host ~]$ mv file1.txt file2.txt file3.txt archive/

# Rename a directory
[user@host ~]$ mv old_project new_project

# Move directory to new location
[user@host ~]$ mv projects /tmp/

Key difference: cp creates a copy (original remains). mv relocates (original is gone from source).

The mv command moves files and directories. Unlike cp, which creates a duplicate, mv relocates - the source is gone after the operation. In Linux, renaming is just moving within the same directory to a different name. There is no separate rename command. mv oldname.txt newname.txt renames the file. mv file.txt Documents/ moves file.txt into Documents, keeping its name. mv file.txt Documents/newname.txt moves and renames in one step. Like cp, you can move multiple files to a directory by listing sources followed by the destination directory. Unlike cp, mv does not need -r for directories. Directories move as single units - the directory and its entire contents are relocated. mv is generally fast when source and destination are on the same filesystem - it just updates the directory entry, not the actual file data. Moving across filesystems is slower because it actually copies data then deletes the source.

mv Options and Safety

# Like cp, mv overwrites without warning by default!
[user@host ~]$ mv newfile.txt existingfile.txt  # existingfile.txt is GONE

# Use -i for interactive (prompts before overwrite)
[user@host ~]$ mv -i newfile.txt existingfile.txt
mv: overwrite 'existingfile.txt'? n

# Use -n to never overwrite
[user@host ~]$ mv -n source.txt destination.txt
# Silently does nothing if destination exists

# Use -v for verbose output
[user@host ~]$ mv -v projects/ archive/
renamed 'projects/' -> 'archive/projects'

# Backup before overwriting
[user@host ~]$ mv --backup=numbered important.txt Documents/
# Creates important.txt.~1~ if Documents/important.txt existed

Critical: mv can destroy data instantly. The overwritten file is not recoverable. Use -i when unsure.

Like cp, mv overwrites existing files without warning by default. This is even more dangerous with mv because both the source file is moved away AND the destination file is overwritten. Two files can become one instantly. The -i option prompts before overwriting - essential for safety. The -n option never overwrites - if the destination exists, mv silently does nothing. Useful in scripts where you want to preserve existing files. The -v option shows what mv is doing - helpful for confirming operations, especially with wildcards or multiple files. The --backup option creates a backup of the destination file before overwriting. The numbered version creates .~1~, .~2~ suffixes for multiple backups. Many administrators add "alias mv='mv -i'" to their shell configuration. This makes mv always prompt before overwriting. You can bypass it with mv -f (force) when you explicitly want to overwrite.

Deleting Files: rm

rm (remove) permanently deletes files. There is no trash can or recycle bin - deleted files are gone.

# Remove a single file
[user@host ~]$ rm unwanted.txt

# Remove multiple files
[user@host ~]$ rm file1.txt file2.txt file3.txt

# Interactive mode - confirm each deletion
[user@host ~]$ rm -i important.txt
rm: remove regular file 'important.txt'? y

# Force removal (no prompts, no errors for missing files)
[user@host ~]$ rm -f maybe_exists.txt

# Verbose - show what's being deleted
[user@host ~]$ rm -v old_file.txt
removed 'old_file.txt'

Warning: rm is permanent. There is no undo. Double-check your command before pressing Enter.

The rm command removes files permanently. This is not like deleting in a graphical environment where files go to a trash folder. When rm deletes a file, it is gone. Recovery requires filesystem forensics tools and is not guaranteed. By default, rm asks for confirmation if a file is write-protected but removes regular files silently. The -i option makes rm ask for confirmation for every file - use this when deleting important files or when using wildcards. The -f option forces removal without any prompts and ignores non-existent files. Useful in scripts, but dangerous interactively. The -v option shows each file as it is deleted - helpful for confirming what was removed. Many administrators alias rm to rm -i for safety. However, this can create a false sense of security - if you rely on the prompt and then work on a system without the alias, you might delete files accidentally.

Deleting Directories

# rmdir removes empty directories only
[user@host ~]$ rmdir empty_folder
[user@host ~]$ rmdir folder_with_files
rmdir: failed to remove 'folder_with_files': Directory not empty

# rm -r removes directories recursively (including contents)
[user@host ~]$ rm -r old_project
# Deletes old_project and everything inside it

# rm -ri for interactive recursive deletion
[user@host ~]$ rm -ri old_project
rm: descend into directory 'old_project'? y
rm: remove regular file 'old_project/file.txt'? y
rm: remove directory 'old_project'? y

# rm -rf - the "dangerous" combination
[user@host ~]$ rm -rf old_project
# Removes everything, no prompts, no errors

DANGER: rm -rf is extremely powerful. A typo like rm -rf / or rm -rf ~/* can destroy your system or all your files. Always verify the path!

Removing directories requires either rmdir for empty directories or rm -r for directories with contents. rmdir is safe - it only removes empty directories. If there is anything inside, it fails. This prevents accidental deletion. rm -r (recursive) removes directories and all their contents - files, subdirectories, and everything within them, recursively. This is powerful and dangerous. rm -ri combines recursive with interactive - it asks about each item. Tedious for large directories but safe for important deletions. rm -rf combines recursive and force - it deletes everything without prompts and ignores errors. This is the most dangerous command combination in Linux. A simple typo can have catastrophic results. rm -rf / (as root) would delete your entire system. rm -rf ~/* would delete all your files. Always double-check paths before running rm -rf. Some administrators never use it interactively, preferring rm -r and responding to prompts.

Wildcards: Globbing

Wildcards (glob patterns) let you match multiple files by pattern. The shell expands them before the command runs.

Pattern	Matches	Example
*	Any characters (zero or more)	*.txt matches all .txt files
?	Any single character	file?.txt matches file1.txt, fileA.txt
[abc]	Any one character from the set	file[123].txt matches file1.txt, file2.txt
[a-z]	Any one character in the range	file[a-c].txt matches filea.txt, fileb.txt
[!abc]	Any character NOT in the set	file[!0-9].txt matches fileA.txt, not file1.txt

# List all .txt files
[user@host ~]$ ls *.txt

# Match files with specific patterns
[user@host ~]$ ls report_202?.pdf    # report_2021.pdf, report_2024.pdf
[user@host ~]$ ls image[1-5].jpg     # image1.jpg through image5.jpg

Wildcards, also called glob patterns, let you work with multiple files based on name patterns. The shell expands wildcards before the command runs - so the command sees a list of actual filenames. The asterisk matches any sequence of characters, including none. *.txt matches anything ending in .txt. backup* matches anything starting with backup. The question mark matches exactly one character. file?.txt matches file1.txt or fileA.txt but not file10.txt (that is two characters). Square brackets match any single character from a set. [abc] matches a, b, or c. [0-9] matches any digit. [a-zA-Z] matches any letter. An exclamation mark inside brackets negates - [!0-9] matches any non-digit. These patterns work with any command that takes filenames - ls, cp, mv, rm, and many others. The shell does the expansion, not the command itself.

Using Wildcards Effectively

# Copy all .txt files to backup directory
[user@host ~]$ cp *.txt backup/

# Move all log files from 2024
[user@host ~]$ mv *2024*.log archive/

# Delete all .tmp files
[user@host ~]$ rm *.tmp

# List files matching complex pattern
[user@host ~]$ ls report_[0-9][0-9][0-9][0-9].pdf   # 4-digit year

# SAFETY: Preview before destructive operations!
[user@host ~]$ ls *.bak                # See what matches
file1.bak  file2.bak  oldstuff.bak
[user@host ~]$ rm *.bak                # Now delete (if correct)

# Echo shows expansion without executing
[user@host ~]$ echo rm *.tmp
rm file1.tmp file2.tmp temp.tmp

Best practice: Before rm with wildcards, use ls with the same pattern to verify what matches!

Wildcards are powerful but require care, especially with destructive operations like rm. The best practice is to preview before executing. Before rm *.bak, run ls *.bak to see exactly which files match. If the list looks right, proceed with rm. Another technique is to use echo. echo rm *.tmp shows you the full command after expansion. You see exactly what rm would receive. Wildcards work with all file operations - cp, mv, rm, and more. You can copy all log files, move all images, delete all temporaries - patterns let you work efficiently with groups of files. Be aware that if no files match a pattern, the behavior depends on shell settings. By default, the literal pattern is passed to the command, which usually results in an error. With some shell options, unmatched patterns expand to nothing.

Brace Expansion

Brace expansion generates multiple text strings. Unlike wildcards, it does not match existing files - it creates strings.

# Create multiple directories at once
[user@host ~]$ mkdir -p project/{src,docs,tests,build}
[user@host ~]$ ls project/
build  docs  src  tests

# Create numbered directories
[user@host ~]$ mkdir chapter{1..5}
[user@host ~]$ ls
chapter1  chapter2  chapter3  chapter4  chapter5

# Create backup with date suffix
[user@host ~]$ cp config.txt{,.bak}
# Expands to: cp config.txt config.txt.bak

# Create multiple files with pattern
[user@host ~]$ touch file{a..e}.txt
[user@host ~]$ ls *.txt
filea.txt  fileb.txt  filec.txt  filed.txt  filee.txt

# Nested expansion
[user@host ~]$ mkdir -p {dev,staging,prod}/{app,db,cache}
# Creates 9 directories: dev/app, dev/db, dev/cache, staging/app, ...

Brace expansion is different from wildcards. Wildcards match existing files. Brace expansion generates strings regardless of what exists. Comma-separated values in braces expand to multiple items. {src,docs,tests} becomes three strings: src docs tests. This is perfect for creating multiple directories or files with one command. Range expansion with two dots generates sequences. {1..5} becomes 1 2 3 4 5. {a..e} becomes a b c d e. The clever pattern file{,.bak} expands to two strings: file and file.bak. This is a quick way to create a backup copy: cp config.txt{,.bak} copies config.txt to config.txt.bak. Nested braces multiply. {dev,prod}/{app,db} creates four combinations: dev/app, dev/db, prod/app, prod/db. Powerful for setting up complex directory structures. Brace expansion happens before wildcard expansion in the shell, and unlike wildcards, empty braces or non-matching ranges are not special.

Working with Hidden Files

Files starting with a dot (.) are hidden. They do not appear in normal ls output and wildcards do not match them by default.

# List including hidden files
[user@host ~]$ ls -a
.  ..  .bashrc  .bash_history  Documents  file.txt

# Wildcard * does NOT match hidden files
[user@host ~]$ ls *
Documents  file.txt

# To include hidden files, be explicit
[user@host ~]$ ls .[!.]* *
# .[!.]* matches dot files but not . and ..

# Copy all files including hidden
[user@host ~]$ cp -r source/. destination/
# The trailing /. copies contents including hidden files

# Move hidden files
[user@host ~]$ mv .config .config.bak    # Rename hidden dir

# Be careful with hidden files and rm!
[user@host ~]$ rm -rf .*    # DANGER: May match .. (parent!)
[user@host ~]$ rm -rf .[!.]*  # Safer: excludes . and ..

Hidden files in Linux are simply files starting with a dot. They are hidden from normal ls output, not for security but for cleanliness - they are typically configuration files that clutter listings. ls -a shows all files including hidden ones. The . and .. entries are the current and parent directories - they always exist. By default, the asterisk wildcard does not match hidden files. ls * shows only non-hidden files. This is usually what you want, but sometimes you need to include hidden files. To match hidden files with wildcards, use patterns like .* - but be careful! .* matches . and .. as well. The pattern .[!.]* matches dot-files but excludes . and .. by requiring the second character to not be a dot. When copying directory contents including hidden files, cp -r source/. destination/ works well - the trailing /. means contents of the directory. Be very careful with rm and hidden file patterns. rm -rf .* might match .. and try to delete the parent directory - modern rm usually prevents this, but do not rely on it.

Practical File Organization

# Create a project structure
[user@host ~]$ mkdir -p myproject/{src,docs,tests,config}
[user@host ~]$ touch myproject/src/{main,utils,config}.py
[user@host ~]$ touch myproject/docs/{README,INSTALL,CHANGELOG}.md

# Organize downloaded files by extension
[user@host Downloads]$ mkdir -p images documents archives
[user@host Downloads]$ mv *.jpg *.png *.gif images/
[user@host Downloads]$ mv *.pdf *.doc *.docx documents/
[user@host Downloads]$ mv *.zip *.tar.gz *.rar archives/

# Archive old logs by date
[user@host logs]$ mkdir -p archive/2024/{01..12}
[user@host logs]$ mv access.log.2024-01-* archive/2024/01/

# Clean up temporary files
[user@host ~]$ find . -name "*.tmp" -delete
[user@host ~]$ find . -name "*~" -delete     # Editor backup files

Tip: Consistent organization saves time. Create standard directory structures for projects and stick to them.

Let us look at practical file organization scenarios. Creating a project structure with mkdir -p and brace expansion is efficient - one command creates the entire hierarchy. Adding touch with brace expansion creates placeholder files. Organizing downloads by type is a common task. Create category directories, then use wildcards to move groups of files by extension. Some patterns might not match any files - that is fine, mv just reports no match. Archiving files by date keeps things manageable. The brace expansion {01..12} creates twelve month directories. Then move files matching date patterns to appropriate months. For cleanup, the find command with -delete is powerful. It finds files matching patterns anywhere in the directory tree and removes them. Use this for temporary files, editor backups, and other clutter. Regular organization prevents chaos. Spending a few minutes organizing now saves hours of searching later.

Common Mistakes

File operations can cause data loss. Know the common mistakes and how to prevent them.

Mistake	Result	Prevention
`rm -rf /important` typo as `rm -rf / important`	Deletes root filesystem!	No space! Use tab completion. Modern rm blocks `rm -rf /`
`mv * ..` in wrong directory	Moves files to wrong parent	Use pwd first. Use absolute paths
`cp file1 file2` where file2 exists	file2 is overwritten	Use `cp -i` or check first
`rm *.txt` in wrong directory	Deletes wrong files	Use `ls *.txt` first, verify with pwd
Wildcard with space: `rm * .txt`	Deletes ALL files plus file named ".txt"	No space in pattern. Use quotes if needed

# Safe practices
[user@host ~]$ pwd                    # Know where you are
[user@host ~]$ ls *.log               # Preview pattern matches
[user@host ~]$ rm -i *.log            # Confirm each deletion

Data loss from file operations is often unrecoverable. Learn common mistakes to avoid them. The space in rm -rf / important is catastrophic - it deletes root, then a directory named important. Tab completion helps prevent this by completing actual paths. Moving files in the wrong directory is easy when you lose track of your location. Always pwd to confirm your position, especially before destructive operations. Overwriting files with cp or mv happens silently by default. Use -i options or verify destinations before operations. Wildcards matching the wrong files is common when you are in the wrong directory or the pattern is broader than intended. Preview with ls or echo first. A space in a wildcard pattern breaks the pattern. rm * .txt does not delete .txt files - it deletes everything, then tries to delete a file literally named .txt. Safe habits: always know your current directory, preview patterns before acting, use interactive modes for important operations, and use absolute paths when working on critical files.

Commands Summary

Command	Purpose	Key Options
touch	Create empty file / update timestamp	(rarely needs options)
mkdir	Create directories	`-p` create parents
cp	Copy files and directories	`-r` recursive, `-i` interactive, `-p` preserve, `-a` archive
mv	Move / rename files and directories	`-i` interactive, `-n` no-clobber, `-v` verbose
rm	Remove files	`-r` recursive, `-i` interactive, `-f` force
rmdir	Remove empty directories	`-p` remove parents too

Wildcards
* any chars ? one char [abc] set [a-z] range

Brace Expansion
{a,b,c} list {1..10} range {a..z} sequence

Let me summarize the commands we have covered. touch creates empty files or updates timestamps. It rarely needs options. mkdir creates directories. The -p option creates parent directories and is almost always what you want. cp copies files and directories. Use -r for directories, -i for safety, -p to preserve attributes, -a for full archive copies. mv moves and renames. Use -i for safety, -n to prevent overwrites, -v to see what is happening. rm removes files and directories. Use -r for directories, -i for safety, -f to force (carefully!). rmdir removes only empty directories - it is safe but limited. Wildcards let you match existing files by pattern - asterisk, question mark, brackets. Brace expansion generates strings - useful for creating multiple items efficiently. Together, these commands and patterns cover the vast majority of file management tasks you will encounter.

Best Practices

Do

Use pwd before destructive operations
Preview wildcards with ls before rm
Use -i for interactive confirmation
Use tab completion to avoid typos
Use -v for verbose output when unsure
Back up before major changes
Use absolute paths for critical operations
Double-check rm -rf commands

Do Not

Run rm -rf without verification
Use wildcards without previewing
Assume you know your current directory
Ignore overwrite warnings
Type paths without tab completion
Delete files you might need later
Skip backups before risky operations
Use -f routinely (defeats safeguards)

Professional habit: Think before you type. Verify before you execute. Especially with rm.

Best practices prevent costly mistakes. Always use pwd before destructive operations - know exactly where you are. Preview wildcards with ls or echo before using them with rm or mv. Use -i for interactive confirmation on important operations. Use tab completion religiously - it confirms paths exist and prevents typos. Use -v for verbose output when you want to see exactly what is happening. Back up important files before making changes - a quick cp can save hours of recovery work. Use absolute paths for critical operations to avoid confusion about relative locations. And always, always double-check rm -rf commands before pressing Enter. Do not run rm -rf casually. Do not use wildcards blindly. Do not assume anything about your location or file state. Do not ignore warnings. Do not rely on -f to solve problems. Do not delete files you might need - disk space is cheap, lost data is expensive. Do not skip backups. The professional habit is to think, then verify, then execute. Take an extra second now to save hours later.

LAB EXERCISES

Create a project directory structure with subdirectories
Copy files between directories, preserving attributes
Move and rename files and directories
Use wildcards to copy/move groups of files
Practice safe deletion with ls preview and rm -i
Organize files by type using wildcards

Next: File Permissions and Ownership

Let me summarize the essential file management skills. Creating files and directories uses touch and mkdir. The -p option for mkdir creates parent directories. Brace expansion efficiently creates multiple items at once. Copying uses cp for files and cp -r for directories. The -a option preserves all attributes - use it for backups and when you need exact copies. Moving and renaming both use mv. Remember that mv relocates - the source is gone, only the destination remains. This is different from cp which keeps the original. Deletion uses rm for files and rm -r for directories. This is permanent - there is no trash can. Always verify with ls before running rm, especially with wildcards. Use rm -i for confirmation. Organization relies on wildcards and brace expansion. Wildcards match existing files by pattern. Braces generate strings for creating multiple items.

Graded Lab

Create a project directory structure with subdirectories
Copy files between directories, preserving attributes
Move and rename files and directories
Use wildcards to copy/move groups of files
Practice safe deletion with ls preview and rm -i
Organize files by type using wildcards

Next: File Permissions and Ownership