# Create a new empty file
touch newfile.txt
 
# Create multiple files at once
touch file1.txt file2.txt file3.txt
 
# Create files with a pattern using brace expansion
touch report_{jan,feb,mar,apr}.txt
# Creates: report_jan.txt, report_feb.txt, report_mar.txt, report_apr.txt
 
# Create numbered files
touch log_{01..10}.txt
# Creates: log_01.txt through log_10.txt
 
# Create a complex structure
touch {2023,2024,2025}_report_{Q1,Q2,Q3,Q4}.txt
# Creates: 2023_report_Q1.txt, 2023_report_Q2.txt, ... 2025_report_Q4.txt
 
# Update the timestamp of an existing file (without modifying content)
touch existingfile.txt
 
# Set specific timestamp
touch -t 202401151030 file.txt  # Jan 15, 2024 10:30
touch -d "2024-01-15 10:30:00" file.txt  # Same, more readable

# Using echo (for simple one-liners)
echo "Hello, World!" > greeting.txt
 
# Append to existing file
echo "Another line" >> greeting.txt
 
# Using printf (for formatted text)
printf "Name: %s\nAge: %d\nCity: %s\n" "Alice" 30 "Seattle" > profile.txt
 
# Using cat with heredoc (for multi-line content)
cat > notes.txt << 'EOF'
Meeting Notes - January 15, 2024
=================================
1. Project update - on track
2. Budget review - approved
3. Next steps - deploy to staging
EOF
 
# Heredoc with variable expansion
cat > config.sh << EOF
#!/bin/bash
USER=$USER
HOME=$HOME
DATE=$(date +%Y-%m-%d)
EOF
 
# Using tee (write to file AND display on screen)
echo "Important log entry" | tee logfile.txt
 
# Tee with append
echo "Another entry" | tee -a logfile.txt
 
# Write to multiple files at once
echo "Same content everywhere" | tee file1.txt file2.txt file3.txt
 
# Create file from command output
ls -la > directory_listing.txt
df -h > disk_usage.txt
ps aux > process_list.txt

# Create a quick backup script
cat > backup.sh << 'EOF'
#!/bin/bash
tar -czf backup_$(date +%Y%m%d).tar.gz /home/$USER/Documents
echo "Backup completed: backup_$(date +%Y%m%d).tar.gz"
EOF
 
chmod +x backup.sh
./backup.sh

# Display a file
cat file.txt
 
# Display with line numbers
cat -n file.txt
 
# Display with line numbers (non-blank lines only)
cat -b file.txt
 
# Show invisible characters (tabs as ^I, end-of-line as $)
cat -A file.txt
# Useful for debugging whitespace issues
 
# Show non-printing characters
cat -v file.txt
 
# Squeeze blank lines (show only one blank line)
cat -s file.txt
 
# Concatenate multiple files
cat file1.txt file2.txt file3.txt
 
# Concatenate and save to a new file
cat header.txt body.txt footer.txt > complete.txt
 
# Append one file to another
cat additional.txt >> main.txt
 
# Number all output lines
cat -n file1.txt file2.txt > numbered_combined.txt

# Inefficient (spawns unnecessary process)
cat file.txt | grep "pattern"
 
# Efficient (grep can read files directly)
grep "pattern" file.txt
 
# Inefficient
cat file.txt | wc -l
 
# Efficient
wc -l < file.txt
# Or even better:
wc -l file.txt

# View a file
less largefile.txt
 
# View with line numbers
less -N file.txt
 
# Case-insensitive search by default
less -i file.txt
 
# Follow mode (like tail -f)
less +F /var/log/syslog
# Press Ctrl+C to stop following, then navigate
# Press F again to resume following
 
# Open multiple files
less file1.txt file2.txt
# Use :n for next file, :p for previous

# First 10 lines (default)
head file.txt
 
# First 20 lines
head -n 20 file.txt
head -20 file.txt       # Shorthand
 
# First 100 bytes
head -c 100 file.txt
 
# First lines of multiple files (shows filenames)
head file1.txt file2.txt file3.txt
 
# Last 10 lines (default)
tail file.txt
 
# Last 20 lines
tail -n 20 file.txt
tail -20 file.txt
 
# Last 100 bytes
tail -c 100 file.txt
 
# Follow a file in real-time (perfect for logs!)
tail -f /var/log/syslog
# Press Ctrl+C to stop
 
# Follow and retry if file is recreated (better for logs that rotate)
tail -F /var/log/application.log
 
# Show all lines EXCEPT the first 5
tail -n +6 file.txt
 
# Show all lines EXCEPT the last 5
head -n -5 file.txt
 
# Lines 10-20 of a file
head -20 file.txt | tail -11
# Or with sed:
sed -n '10,20p' file.txt
 
# Follow multiple files simultaneously
tail -f /var/log/syslog /var/log/auth.log

# Monitor a web server access log in real-time
tail -f /var/log/nginx/access.log
 
# Watch the last 50 lines of a growing log file
tail -n 50 -f application.log
 
# Show just the header of a CSV file
head -1 data.csv
 
# Remove the header from a CSV
tail -n +2 data.csv > data_without_header.csv
 
# See the first and last lines of a file
head -n 1 file.txt && tail -n 1 file.txt
 
# Extract lines 100-200 from a massive file
sed -n '100,200p' huge_file.txt
# Or:
head -200 huge_file.txt | tail -101

# Count lines, words, and characters
wc file.txt
# Output: 42  156  1024 file.txt
# (42 lines, 156 words, 1024 bytes)
 
# Count only lines
wc -l file.txt
 
# Count only words
wc -w file.txt
 
# Count only characters
wc -m file.txt
 
# Count only bytes
wc -c file.txt
 
# Count for multiple files (shows total)
wc -l *.txt
 
# Count lines in command output
ls | wc -l                    # How many files?
grep "error" logfile.txt | wc -l  # How many errors?
ps aux | wc -l                # How many processes?
 
# Find longest line
wc -L file.txt

# Count total lines of code in a project
find . -name "*.py" | xargs wc -l
 
# Count files in a directory
ls -1 | wc -l
 
# Count unique IP addresses in access log
awk '{print $1}' access.log | sort -u | wc -l
 
# Count occurrences of a word
grep -o "error" logfile.txt | wc -l

# Copy a file (basic syntax)
cp source.txt destination.txt
 
# Copy a file to a directory (keeps original name)
cp file.txt /path/to/directory/
 
# Copy multiple files to a directory
cp file1.txt file2.txt file3.txt /path/to/directory/
 
# Copy with wildcards
cp *.jpg /path/to/photos/
cp report_*.pdf /path/to/archive/
 
# Copy a directory (must use -r for recursive)
cp -r source_dir/ destination_dir/
 
# Copy and preserve attributes (timestamps, permissions, ownership)
cp -p file.txt backup.txt
# Useful for backups where you want original timestamps
 
# Copy preserving everything (archive mode)
cp -a source_dir/ destination_dir/
# Equivalent to: cp -dpR
# -a preserves: permissions, ownership, timestamps, symlinks
 
# Interactive: ask before overwriting
cp -i file.txt existing_file.txt
 
# Verbose: show what's being copied
cp -v file1.txt file2.txt /backup/
# Output: 'file1.txt' -> '/backup/file1.txt'
#         'file2.txt' -> '/backup/file2.txt'
 
# Don't overwrite existing files
cp -n file.txt existing_file.txt
# Silently skips if destination exists
 
# Update: copy only if source is newer
cp -u source.txt destination.txt
# Only copies if source.txt is newer than destination.txt
 
# Force: always overwrite without prompting
cp -f file.txt destination.txt
 
# Create backup of existing destination file
cp -b file.txt existing.txt
# Creates existing.txt~ as backup
 
# Copy hard links as links (not as separate files)
cp -d link destination/
 
# Combine options for comprehensive copy
cp -av source/ backup/
# Archive mode + verbose

# Backup a configuration file before editing
cp -p /etc/nginx/nginx.conf /etc/nginx/nginx.conf.backup
 
# Copy entire directory structure preserving everything
cp -a /var/www/html /var/www/html.backup
 
# Copy only PDF files from multiple subdirectories
find . -name "*.pdf" -exec cp {} /backup/pdfs/ \;
 
# Copy files modified today
cp -u $(find . -mtime 0) /backup/today/
 
# Mirror a directory to another location
cp -auv /source/ /destination/

# Rename a file (same directory)
mv oldname.txt newname.txt
 
# Move a file to a directory
mv file.txt /path/to/directory/
 
# Move multiple files to a directory
mv file1.txt file2.txt file3.txt /path/to/directory/
 
# Move with wildcards
mv *.log /var/log/archive/
 
# Move a directory (to another location)
mv old_dir/ /new/location/
 
# Rename a directory
mv old_dirname/ new_dirname/
 
# Interactive: ask before overwriting
mv -i file.txt existing_file.txt
 
# Verbose: show what's being moved
mv -v *.txt /archive/
# Output: 'file1.txt' -> '/archive/file1.txt'
#         'file2.txt' -> '/archive/file2.txt'
 
# Don't overwrite existing files
mv -n file.txt destination.txt
 
# Move only if source is newer (update mode)
mv -u source.txt destination.txt
 
# Force: overwrite read-only files
mv -f file.txt /destination/
 
# Backup existing destination file
mv -b file.txt existing.txt
# Creates existing.txt~ as backup

# Organize downloads by file type
mv ~/Downloads/*.pdf ~/Documents/PDFs/
mv ~/Downloads/*.jpg ~/Pictures/
 
# Rename all .txt files to .md
for file in *.txt; do
    mv "$file" "${file%.txt}.md"
done
 
# Move files older than 30 days to archive
find . -mtime +30 -exec mv {} /archive/ \;
 
# Rename with date prefix
mv report.txt "$(date +%Y%m%d)_report.txt"
 
# Swap two files (requires temp file)
mv file1.txt temp.tmp
mv file2.txt file1.txt
mv temp.tmp file2.txt
 
# Move files matching pattern with confirmation
mv -i log_*.txt /archive/

# Delete a file
rm file.txt
 
# Delete multiple files
rm file1.txt file2.txt file3.txt
 
# Delete with wildcard
rm *.tmp
 
# Interactive: ask before each deletion
rm -i file.txt
rm: remove regular file 'file.txt'? y
 
# Interactive for 3+ files (less annoying)
rm -I *.txt
rm: remove 5 arguments? y
 
# Force: don't ask, don't error on missing files
rm -f file.txt
rm -f nonexistent.txt  # Doesn't complain
 
# Delete a directory and all its contents (recursive)
rm -r directory/
rm -rf directory/  # Force + recursive (most common for directories)
 
# Verbose: show what's being deleted
rm -v *.log
# Output: removed 'app.log'
#         removed 'error.log'
 
# Delete empty directories only
rmdir empty_directory/
 
# Delete a directory tree of empty directories
rmdir -p a/b/c/    # Removes c/, then b/, then a/ (if all empty)

# Remove all .tmp files older than 7 days
find . -name "*.tmp" -mtime +7 -delete
 
# Remove all but the most recent 10 backup files
ls -t backup_*.tar.gz | tail -n +11 | xargs rm -f
 
# Remove all empty files
find . -type f -empty -delete
 
# Remove files interactively from a list
find . -name "*.log" -size +100M -ok rm {} \;
 
# Clean up compiled Python files
find . -name "*.pyc" -delete
find . -name "__pycache__" -type d -delete
 
# Remove backup files
rm *~ *.bak *.old
 
# Safely remove a directory with confirmation
rm -rI large_directory/

# Create a single directory
mkdir new_directory
 
# Create nested directories (parent directories too)
mkdir -p projects/webapp/src/components
# Without -p, would fail if projects/ doesn't exist
 
# Create multiple directories at once
mkdir dir1 dir2 dir3
 
# Create with specific permissions
mkdir -m 755 public_dir
mkdir -m 700 private_dir
# Same as: mkdir dir && chmod 755 dir
 
# Verbose: show what's being created
mkdir -v new_dir
# Output: mkdir: created directory 'new_dir'
 
# Create a project structure in one command
mkdir -p myproject/{src,tests,docs,config}
# Creates:
# myproject/
# ├── src/
# ├── tests/
# ├── docs/
# └── config/
 
# More complex structure
mkdir -p myapp/{src/{components,utils,hooks},public/{images,css,js},tests/{unit,integration}}
# Creates:
# myapp/
# ├── src/
# │   ├── components/
# │   ├── utils/
# │   └── hooks/
# ├── public/
# │   ├── images/
# │   ├── css/
# │   └── js/
# └── tests/
#     ├── unit/
#     └── integration/
 
# Create date-stamped backup directories
mkdir -p backups/$(date +%Y/%m/%d)
# Creates: backups/2024/01/15/
 
# Create numbered directories
mkdir -p project/{phase1,phase2,phase3}/{planning,execution,review}

# Set up a standard web project structure
mkdir -p website/{css,js,images,fonts,pages}
 
# Create log directories with proper permissions
sudo mkdir -p /var/log/myapp
sudo chmod 755 /var/log/myapp
 
# Organize photos by date
mkdir -p ~/Pictures/$(date +%Y)/$(date +%m)
 
# Create a complete Python project structure
mkdir -p python_project/{src/package,tests,docs,scripts}
touch python_project/src/package/__init__.py
touch python_project/README.md
touch python_project/requirements.txt

# Numeric method (octal)
chmod 755 script.sh      # rwxr-xr-x (owner: full, others: read+execute)
chmod 644 document.txt   # rw-r--r-- (owner: read+write, others: read-only)
chmod 700 private/       # rwx------ (owner-only access)
chmod 600 secrets.txt    # rw------- (owner can read/write, no one else)
 
# Symbolic method (more flexible)
chmod u+x script.sh      # Add execute for owner (user)
chmod g+w file.txt       # Add write for group
chmod o-r file.txt       # Remove read for others
chmod a+r file.txt       # Add read for all (a = all = ugo)
 
# Multiple changes at once
chmod u+rwx,g+rx,o+r file.txt  # Owner: full, group: read+execute, others: read
 
# Set exact permissions (= instead of +/-)
chmod u=rwx,g=rx,o=r file.txt  # Same as 754
 
# Copy permissions from one category to another
chmod g=u file.txt       # Group gets same permissions as owner
 
# Recursive (apply to directory and all contents)
chmod -R 755 project/
 
# Recursive for files and directories differently
find project/ -type f -exec chmod 644 {} \;   # Files: 644
find project/ -type d -exec chmod 755 {} \;   # Directories: 755
 
# Add execute permission to all .sh files
chmod +x *.sh
 
# Remove write permission for group and others
chmod go-w *
 
# Make file readable by everyone, writable only by owner
chmod 644 document.txt
# Or symbolically:
chmod u=rw,go=r document.txt

# Web server files
chmod 644 *.html *.css *.js     # Web assets
chmod 755 cgi-bin/*.cgi         # CGI scripts
chmod 600 config/database.php   # Database credentials
 
# SSH keys (must be restricted!)
chmod 700 ~/.ssh                # SSH directory
chmod 600 ~/.ssh/id_rsa         # Private key
chmod 644 ~/.ssh/id_rsa.pub     # Public key
chmod 644 ~/.ssh/authorized_keys # Authorized keys
chmod 644 ~/.ssh/known_hosts    # Known hosts
 
# Shell scripts
chmod +x script.sh              # Make executable
chmod 755 /usr/local/bin/myscript  # System-wide script
 
# Log files
chmod 640 /var/log/myapp.log    # Owner+group read, owner write
 
# Shared project directory
chmod 775 shared_project/        # Owner+group can do everything

# Change owner
sudo chown alice file.txt
 
# Change owner and group
sudo chown alice:staff file.txt
 
# Change group only
sudo chown :staff file.txt
# Or use chgrp:
sudo chgrp staff file.txt
 
# Recursive (directory and all contents)
sudo chown -R alice:staff project/
 
# Follow symbolic links (change link targets, not links)
sudo chown -L alice file.txt
 
# Change from one user to another (security cleanup)
sudo chown -R newuser:newuser --from=olduser:olduser /var/www/
 
# Verbose: show what's being changed
sudo chown -v alice file.txt
# Output: changed ownership of 'file.txt' from root to alice
 
# Reference file (copy ownership from another file)
sudo chown --reference=template.txt newfile.txt

# Fix ownership after sudo operations
sudo chown -R $USER:$USER ~/myproject
 
# Set up web server files
sudo chown -R www-data:www-data /var/www/html
 
# Give ownership to a specific user
sudo chown -R bob:developers /opt/project
 
# Change ownership of all files owned by old user
sudo find /home -user olduser -exec chown newuser {} \;

# Basic syntax: find [path] [tests] [actions]
 
# Find by name (case-sensitive)
find /home -name "report.txt"
find . -name "*.py"
 
# Case-insensitive name search
find . -iname "readme*"
 
# Find by type
find . -type f          # Regular files only
find . -type d          # Directories only
find . -type l          # Symbolic links only
find . -type b          # Block devices
find . -type c          # Character devices
 
# Find by size
find . -size +100M      # Files larger than 100MB
find . -size -1k        # Files smaller than 1KB
find . -size 50M        # Files exactly 50MB
find /var/log -size +1G # Huge log files
 
# Find by modification time
find . -mtime -7        # Modified in the last 7 days
find . -mtime +30       # Modified more than 30 days ago
find . -mtime 0         # Modified today
find . -mmin -60        # Modified in the last 60 minutes
 
# Find by access time
find . -atime -1        # Accessed in the last 24 hours
 
# Find by change time (metadata change)
find . -ctime -7        # Changed in the last 7 days
 
# Find by permissions
find . -perm 644        # Exact match
find . -perm -u+x       # At least owner execute
find . -perm /u+w       # Owner has write (any)
 
# Find by owner
find . -user alice
find . -group staff
find /home -user bob -group developers
 
# Find empty files/directories
find . -empty
find /tmp -type f -empty  # Empty files only
 
# Find by depth
find . -maxdepth 2 -name "*.txt"  # Only 2 levels deep
find . -mindepth 2 -name "*.log"  # At least 2 levels deep
 
# Combine criteria (AND by default)
find . -name "*.log" -size +10M -mtime +30
# Finds .log files larger than 10MB, modified more than 30 days ago
 
# OR criteria
find . -name "*.jpg" -o -name "*.png"
find . \( -name "*.txt" -o -name "*.md" \) -size +1M
 
# NOT criteria
find . ! -name "*.tmp"
find . -not -name "*.log"
 
# Exclude directories
find . -name "*.py" -not -path "*/venv/*"
find . -name "*.js" -not -path "*/node_modules/*"

# Delete found files (BE CAREFUL!)
find /tmp -name "*.tmp" -mtime +7 -delete
 
# Execute a command on each found file
find . -name "*.txt" -exec cat {} \;
find . -name "*.sh" -exec chmod +x {} \;
# {} is replaced with the found filename
# \; ends the -exec command
 
# Execute with confirmation (interactive)
find . -name "*.log" -ok rm {} \;
# Asks: < rm ... ./file.log > ? y
 
# Execute multiple commands
find . -name "*.txt" -exec echo "Processing: {}" \; -exec wc -l {} \;
 
# Use + instead of \; to pass multiple files at once (faster)
find . -name "*.txt" -exec grep "pattern" {} +
# Equivalent to: grep "pattern" file1.txt file2.txt file3.txt
 
# Print with details (like ls -l)
find . -name "*.py" -ls
 
# Print full path
find . -name "*.txt" -print
# Or with null separator (safe for filenames with spaces)
find . -name "*.txt" -print0
 
# Use xargs for better performance (handles spaces correctly)
find . -name "*.txt" -print0 | xargs -0 grep "error"
find . -type f -name "*.log" -print0 | xargs -0 gzip

# Find and count all Python files
find . -name "*.py" | wc -l
 
# Find large log files and compress them
find /var/log -name "*.log" -size +100M -exec gzip {} \;
 
# Find files not accessed in 90 days and archive
find /data -type f -atime +90 -exec mv {} /archive/ \;
 
# Find broken symbolic links
find . -type l ! -exec test -e {} \; -print
 
# Find duplicate files by size (first pass)
find . -type f -exec ls -lS {} + | awk '{print $5, $NF}' | sort -n
 
# Find world-writable files (security audit)
find / -perm -002 -type f -print 2>/dev/null
 
# Find SetUID/SetGID programs (security audit)
find / -perm /6000 -type f -ls 2>/dev/null
 
# Find all shell scripts
find . -type f -name "*.sh" -o -name "*.bash"
 
# Find files owned by specific user
find /home -user olduser -exec chown newuser:newuser {} +
 
# Find and remove empty directories
find . -type d -empty -delete
 
# Find files modified between two dates
find . -type f -newermt "2024-01-01" ! -newermt "2024-02-01"
 
# Find files by inode number (useful after accidental deletion)
find . -inum 123456

# Update the database first (run daily via cron usually)
sudo updatedb
 
# Search for a file
locate report.txt
 
# Case-insensitive search
locate -i readme
 
# Count matches
locate -c "*.py"
 
# Show only existing files (database might be stale)
locate -e report.txt
 
# Limit number of results
locate -l 10 "*.log"
 
# Show database statistics
locate -S
 
# Use basic regex
locate -r "report.*\.pdf$"
 
# Match only basename (not full path)
locate -b "\report.txt"

# Fast search for filenames
locate nginx.conf
 
# Comprehensive real-time search with criteria
find / -name "nginx.conf" -type f -newer /tmp/marker 2>/dev/null

# Find where a command's binary is
which python
# /usr/bin/python
 
which ls
# /usr/bin/ls
 
which -a python
# Show ALL occurrences in PATH
# /usr/bin/python
# /usr/local/bin/python
 
# Find binary, source, and manual pages
whereis ls
# ls: /usr/bin/ls /usr/share/man/man1/ls.1.gz
 
whereis python
# python: /usr/bin/python /usr/lib/python3.10 /usr/share/man/man1/python.1.gz
 
# Show how the shell interprets a command
type cd
# cd is a shell builtin
 
type ls
# ls is aliased to 'ls --color=auto'
 
type python
# python is /usr/bin/python
 
type -a python
# Show all definitions
# python is /usr/bin/python
# python is /usr/local/bin/python
 
type -t ls
# Show type only: alias, keyword, function, builtin, file
# alias

# Verify which Python you're using
which python && python --version
 
# Find all installed versions of a program
whereis -b python
 
# Check if a command is available
if command -v docker &> /dev/null; then
    echo "Docker is installed"
fi
 
# Find what conflicts with your script name
type -a mycommand

# Show disk space for all filesystems
df
 
# Human-readable sizes (KB, MB, GB)
df -h
 
# Show specific filesystem
df -h /home
 
# Show filesystem type
df -hT
 
# Show only local filesystems (exclude network mounts)
df -hl
 
# Show inodes instead of blocks
df -i
 
# Show only specific filesystem type
df -t ext4
 
# Exclude specific filesystem type
df -x tmpfs
 
# Total summary
df -h --total

# Check root filesystem usage
df -h /
 
# Alert if filesystem is >90% full
df -h | awk '$5+0 > 90 {print "WARNING: " $0}'
 
# Monitor specific mount point
df -h /var/log
 
# Check all ext4 filesystems
df -hT | grep ext4

# Size of current directory (summary)
du -sh .
 
# Size of each item in current directory
du -sh *
 
# Size with depth limit (show top-level only)
du -h --max-depth=1
 
# Size with depth=2
du -h --max-depth=2
 
# Find the 10 largest directories
du -h --max-depth=1 | sort -hr | head -10
 
# Size of a specific directory
du -sh /var/log
 
# Exclude certain patterns
du -sh --exclude="*.log" /var
 
# Show grand total at the end
du -ch /var/log | tail -1
 
# All files, not just directories
du -ah
 
# Apparent size (actual file size, not disk blocks)
du -sh --apparent-size file.txt
 
# Show timestamps
du -h --time /var/log/*

# Find what's eating disk space
du -h /home | sort -hr | head -20
 
# Disk usage by file type
find . -name "*.log" -exec du -ch {} + | tail -1
find . -name "*.mp4" -exec du -ch {} + | tail -1
 
# Space used by Docker
sudo du -sh /var/lib/docker
 
# Find large directories in /var
sudo du -h /var | grep "^[0-9\.]*G"
 
# Compare sizes before and after cleanup
du -sh project/ > before.txt
# ... cleanup operations ...
du -sh project/ > after.txt
diff before.txt after.txt
 
# Disk usage excluding hidden files
du -sh --exclude=".*" ~