# Each program starts with three file descriptors open:
# 0 → stdin  (reads from keyboard by default)
# 1 → stdout (writes to terminal by default)
# 2 → stderr (writes to terminal by default)
 
# When you redirect, you're changing where these file descriptors point:
echo "Hello" > file.txt      # Redirect FD 1 (stdout) to file.txt
command 2> errors.txt        # Redirect FD 2 (stderr) to errors.txt
command < input.txt          # Redirect FD 0 (stdin) from input.txt
 

# Basic redirection (stdout to file)
echo "Hello, World!" > greeting.txt
date > timestamp.txt
ls -la /etc > directory_listing.txt
 
# Multiple commands can write to the same file (overwrites each time)
echo "First line" > file.txt
cat file.txt                           # Shows: First line
echo "Second line" > file.txt          # OVERWRITES file.txt!
cat file.txt                           # Shows: Second line only (first line is GONE)
 
# Redirect command output
df -h > disk_usage.txt
ps aux > process_list.txt
history > command_history.txt
 
# Create empty file (truncate if exists)
> empty_file.txt
# Equivalent to: touch empty_file.txt but faster
 
# Combine with other commands
sort names.txt > sorted_names.txt
grep "error" logfile.txt > errors_only.txt
 

# Append to a file (creates if doesn't exist)
echo "Line 1" > log.txt              # Creates file with "Line 1"
echo "Line 2" >> log.txt             # Appends "Line 2"
echo "Line 3" >> log.txt             # Appends "Line 3"
cat log.txt
# Line 1
# Line 2
# Line 3
 
# Perfect for logging
echo "$(date): Application started" >> /var/log/myapp.log
echo "$(date): Processing 1000 records" >> /var/log/myapp.log
echo "$(date): Completed successfully" >> /var/log/myapp.log
 
# Build a report incrementally
echo "=== System Report ===" > report.txt
echo "Generated: $(date)" >> report.txt
echo "" >> report.txt
echo "Disk Usage:" >> report.txt
df -h >> report.txt
echo "" >> report.txt
echo "Memory Usage:" >> report.txt
free -h >> report.txt
 
# Append command outputs
{ date; uptime; df -h; } >> system_status.txt
 

# Create a logging function
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" >> app.log
}
 
# Use it throughout your script
log "Script started"
log "Processing file: data.csv"
log "Found 1523 records"
log "Processing completed"
 
# app.log contains:
# [2024-01-15 10:30:45] Script started
# [2024-01-15 10:30:45] Processing file: data.csv
# [2024-01-15 10:30:47] Found 1523 records
# [2024-01-15 10:30:52] Processing completed
 

# Redirect errors to a file (normal output goes to screen)
find / -name "secret.txt" 2> errors.txt
# Results display on screen, "Permission denied" errors go to errors.txt
 
# Most common use: Discard errors (send to /dev/null)
find / -name "*.conf" 2>/dev/null
# Only shows successful results, suppresses all error messages
 
# Redirect errors to a log
./my_script.sh 2> error_log.txt
# Script runs, normal output to screen, errors to error_log.txt
 
# Append errors to existing log
./my_script.sh 2>> error_log.txt
 
# Separate normal output and errors
command > output.txt 2> errors.txt
# Success messages → output.txt
# Error messages → errors.txt
 

# Without error suppression (messy):
find /etc -name "*.conf"
# Output mixed with:
# find: '/etc/ssl/private': Permission denied
# find: '/etc/polkit-1/localauthority': Permission denied
# ... lots of errors ...
 
# With error suppression (clean):
find /etc -name "*.conf" 2>/dev/null
# Only shows files you can actually read
 

# Discard all output
command > /dev/null
 
# Discard only errors
command 2> /dev/null
 
# Discard everything (stdout and stderr)
command > /dev/null 2>&1
command &> /dev/null           # Shorthand (Bash 4+)
 
# Test if a command exists (discard all output)
if command -v docker &> /dev/null; then
    echo "Docker is installed"
else
    echo "Docker not found"
fi
 
# Silent background process
long_running_command &> /dev/null &
 
# Check if file exists (suppress any errors)
cat /path/to/file 2>/dev/null || echo "File not found"
 

# Redirect both to the SAME file
command > output.txt 2>&1
# Explanation:
# 1. > output.txt     → redirect stdout (FD 1) to output.txt
# 2. 2>&1             → redirect stderr (FD 2) to wherever stdout (FD 1) is going
 
# Shorthand (Bash 4+)
command &> output.txt
 
# Append both to the same file
command >> output.txt 2>&1
command &>> output.txt         # Shorthand
 
# Redirect to DIFFERENT files
command > normal_output.txt 2> errors.txt
# stdout → normal_output.txt
# stderr → errors.txt
 
# Send stdout to file, stderr to screen (default)
command > output.txt
 
# Send stderr to file, stdout to screen (default)
command 2> errors.txt
 
# Swap stdout and stderr (advanced!)
command 3>&1 1>&2 2>&3
# Temporarily use FD 3 to swap FD 1 and FD 2
 
# Discard stdout, keep stderr
command > /dev/null
command 2>&1 > /dev/null      # Discards stdout, stderr goes to screen
 
# Discard stderr, keep stdout
command 2> /dev/null
 

# Log everything (success and errors) with timestamps
{
    echo "=== Script started at $(date) ==="
    ./process_data.sh
    echo "=== Script finished at $(date) ==="
} >> full_log.txt 2>&1
 
# Separate logs for different purposes
./deploy.sh > deployment.log 2> deployment_errors.log
 
# Silent execution but capture errors
./script.sh > /dev/null 2> errors.log
if [ -s errors.log ]; then
    echo "Errors occurred:"
    cat errors.log
fi
 

# Read input from a file
wc -l < /etc/passwd              # Count lines (file content as stdin)
sort < unsorted_list.txt         # Sort file contents
grep "error" < logfile.txt       # Search within file
 
# Equivalent to (but stdin redirection is more explicit):
wc -l /etc/passwd                # Same result (wc accepts filename)
sort unsorted_list.txt
grep "error" logfile.txt
 
# Useful when command expects stdin
cat < file.txt                   # Reads from file instead of keyboard
tr '[:upper:]' '[:lower:]' < input.txt  # Convert to lowercase
 
# stdin redirection with output redirection
tr '[:upper:]' '[:lower:]' < input.txt > output.txt
 
# Commands that require stdin redirection
mysql -u root -p < setup.sql     # Execute SQL from file
python3 < script.py              # Run Python script via stdin
psql -U postgres < backup.sql    # Restore database
 
# Feed data to a loop
while read -r line; do
    echo "Processing: $line"
done < data.txt
 

# These are equivalent for most commands:
grep "pattern" file.txt
grep "pattern" < file.txt
 
# But < is required when:
# 1. Command only reads from stdin
tr 'a-z' 'A-Z' < input.txt       # tr doesn't accept filenames
 
# 2. You want to hide the filename from command
wc -l < file.txt                 # Shows: "42" (just the count)
wc -l file.txt                   # Shows: "42 file.txt" (includes filename)
 
# 3. Combining redirections
command < input.txt > output.txt 2> errors.txt
 

# Basic heredoc syntax
command << DELIMITER
    content line 1
    content line 2
    ...
DELIMITER
 
# Practical example: Create a file with multiple lines
cat << EOF > config.txt
server=localhost
port=8080
debug=false
timeout=30
EOF
 
# Variables are expanded inside heredoc
name="Alice"
cat << EOF
Hello, $name!
Today is $(date).
Your home is $HOME.
EOF
 
# Prevent variable expansion with quoted delimiter
cat << 'EOF'
This is literal: $HOME
No expansion: $(date)
Variables: $name
EOF
 
# Indented heredoc (<<- strips leading TABS, not spaces)
if true; then
    cat <<-EOF
	This line has a leading tab (will be stripped).
	So does this one.
	EOF
fi
 
# Heredoc to a command
mail -s "System Report" admin@example.com << EOF
System: $(hostname)
Uptime: $(uptime)
Disk: $(df -h / | awk 'NR==2{print $5}')
EOF
 
# SQL queries
mysql -u root -p"$password" << EOF
CREATE DATABASE myapp;
USE myapp;
CREATE TABLE users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) UNIQUE NOT NULL,
    email VARCHAR(100) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
INSERT INTO users (username, email) VALUES
    ('alice', 'alice@example.com'),
    ('bob', 'bob@example.com');
EOF
 
# Python script execution
python3 << 'EOF'
import sys
import os
print(f"Python version: {sys.version}")
print(f"Current directory: {os.getcwd()}")
EOF
 

# Generate configuration files
cat > /etc/nginx/sites-available/myapp << EOF
server {
    listen 80;
    server_name example.com;
    root /var/www/myapp;
    index index.html;
 
    location / {
        try_files \$uri \$uri/ =404;
    }
}
EOF
 
# Create scripts on the fly
cat > backup.sh << 'EOF'
#!/bin/bash
DATE=$(date +%Y%m%d)
tar -czf backup_$DATE.tar.gz /home/$USER/documents
echo "Backup completed: backup_$DATE.tar.gz"
EOF
chmod +x backup.sh
 
# Multi-line echo alternative
cat << EOF
╔════════════════════════════════╗
║     Welcome to MyApp v1.0      ║
║  Please select an option:      ║
║  1) Start                      ║
║  2) Configure                  ║
║  3) Exit                       ║
╚════════════════════════════════╝
EOF
 
# Documentation in scripts
: << 'DOCUMENTATION'
Script: backup_system.sh
Purpose: Create full system backup to remote server
Author: Alice
Date: 2024-01-15
Notes: Requires ssh keys to be configured
DOCUMENTATION
 

# Basic here string
grep "error" <<< "This line has an error in it"
# Output: This line has an error in it
 
# Using with variables
message="Hello World from Bash"
wc -w <<< "$message"             # Count words: 4
 
# Read words into an array
line="apple banana cherry date"
read -ra fruits <<< "$line"
echo "${fruits[0]}"              # apple
echo "${fruits[2]}"              # cherry
 
# Parse delimited strings
IFS=',' read -ra items <<< "first,second,third,fourth"
for item in "${items[@]}"; do
    echo "Item: $item"
done
 
# Process command output as string
uptime_output=$(uptime)
read load1 load5 load15 <<< $(echo "$uptime_output" | awk -F'load average:' '{print $2}')
 
# Calculate with bc
result=$(bc <<< "scale=2; 22 / 7")
echo $result                     # 3.14
 
# Multiple lines (use actual newlines)
tr '[:upper:]' '[:lower:]' <<< "HELLO
WORLD
BASH"
 

# These are equivalent:
 
# Here string (cleanest for one line)
grep "pattern" <<< "text to search"
 
# Heredoc (verbose for one line)
grep "pattern" << EOF
text to search
EOF
 
# Echo with pipe (common but spawns extra process)
echo "text to search" | grep "pattern"
 
# Here string with variable
grep "pattern" <<< "$my_variable"
 
# Echo with pipe (equivalent but slower)
echo "$my_variable" | grep "pattern"