Complete Guide to Bash echo Command

Table of Contents

Introduction to echo

The echo command is one of the most fundamental and frequently used commands in Bash. It displays text or variables to the standard output (usually the terminal). Understanding echo is essential for shell scripting, debugging, and creating user-friendly scripts.

Key Concepts

Output Display: Shows text, variables, and command results
Newline Behavior: By default, adds a newline after output
Escape Sequences: Special characters for formatting
Variable Expansion: Displays variable values
Redirection: Can send output to files or other commands

1. Basic echo Syntax

Simple Text Output

# Basic text output
echo "Hello, World!"
echo 'Hello, World!'
echo Hello, World!
# Multiple arguments
echo Hello World from Bash
echo "Hello" "World" "from" "Bash"
# Empty line
echo
echo "Line after empty line"
# Output with spaces preserved
echo "This    has    multiple    spaces"
echo This    has    multiple    spaces    # Spaces collapsed to one

Quotes and Special Characters

# Double quotes allow variable expansion and some escape sequences
echo "Home directory: $HOME"
echo "User: $USER"
# Single quotes prevent expansion (literal)
echo 'Home directory: $HOME'
echo 'User: $USER'
# Mixing quotes
echo "Today is $(date)"
echo 'Today is $(date)'  # Command not executed
# Escaping quotes
echo "He said, \"Hello, World!\""
echo 'He said, "Hello, World!"'
echo "It's a beautiful day"
echo 'It'\''s a beautiful day'  # Complex escaping

2. echo Options

-n (No Newline)

# Without -n (adds newline)
echo -n "Loading"
echo -n "."
echo -n "."
echo -n "."
echo " Done!"
# Useful for prompts
echo -n "Enter your name: "
read name
echo "Hello, $name!"
# Building a line progressively
echo -n "Processing"
for i in {1..5}; do
sleep 0.5
echo -n "."
done
echo " Complete!"

-e (Enable Escape Sequences)

# Without -e, escape sequences are literal
echo "Line1\nLine2"           # Prints: Line1\nLine2
# With -e, escape sequences are interpreted
echo -e "Line1\nLine2"        # Prints two lines
echo -e "Column1\tColumn2\tColumn3"
# Common escape sequences
echo -e "Bell sound: \a"      # Alert (bell)
echo -e "Backspace\b\b\b!!!"  # Backspace
echo -e "Form feed\fnew page" # Form feed
echo -e "Line1\rOverwrite"    # Carriage return
echo -e "Tab\tseparated"      # Horizontal tab
echo -e "Vertical\vtab"       # Vertical tab
echo -e "\\ backslash"        # Backslash

-E (Disable Escape Sequences - Default)

# -E is the default behavior
echo -E "Line1\nLine2"        # Same as echo "Line1\nLine2"
echo "Line1\nLine2"            # Same as above
# Useful when you want literal backslashes
echo -E "Path: C:\Users\name"

3. Working with Variables

Variable Display

# Basic variable display
name="John"
age=30
echo "Name: $name, Age: $age"
# Using curly braces for clarity
echo "Hello, ${name}!"
echo "File: ${file}.txt"
# Default values
echo "Hello, ${name:-Guest}!"
echo "Count: ${count:-0}"
# Variable length
echo "Name length: ${#name}"
# Array variables
colors=("red" "green" "blue")
echo "First color: ${colors[0]}"
echo "All colors: ${colors[@]}"
echo "Number of colors: ${#colors[@]}"

Command Substitution

# Using backticks (older syntax)
echo "Today is `date`"
echo "Current directory: `pwd`"
# Using $() (preferred)
echo "Today is $(date)"
echo "Current directory: $(pwd)"
echo "Files: $(ls | wc -l)"
# Nested command substitution
echo "System: $(uname -o) $(uname -r)"
echo "Uptime: $(uptime | cut -d, -f1)"
# Complex examples
echo "Random number: $((RANDOM % 100))"
echo "Script name: $(basename $0)"
echo "Line count: $(wc -l < file.txt)"

4. Formatting Output

Using printf-style Formatting

# Basic formatting with echo (limited)
printf "Name: %s, Age: %d\n" "John" 30
# Tables and columns
printf "%-10s %-10s %-10s\n" "Name" "Age" "City"
printf "%-10s %-10d %-10s\n" "John" 30 "NYC"
printf "%-10s %-10d %-10s\n" "Alice" 25 "LA"
printf "%-10s %-10d %-10s\n" "Bob" 35 "Chicago"
# Numbers formatting
printf "Decimal: %d\n" 42
printf "Hexadecimal: %x\n" 42
printf "Octal: %o\n" 42
printf "Float: %.2f\n" 3.14159
# Padding and alignment
printf "|%10s|\n" "right"      # Right align
printf "|%-10s|\n" "left"       # Left align
printf "|%*s|\n" 10 "center"    # Dynamic width

Using echo with Formatting

# Simple tables with tabs
echo -e "Name\tAge\tCity"
echo -e "John\t30\tNYC"
echo -e "Alice\t25\tLA"
echo -e "Bob\t35\tChicago"
# Using columns for alignment
{
echo "Name Age City"
echo "John 30 NYC"
echo "Alice 25 LA"
echo "Bob 35 Chicago"
} | column -t
# Box drawing
echo -e "┌────┬─────┐"
echo -e "│ ID │Name │"
echo -e "├────┼─────┤"
echo -e "│ 1  │John │"
echo -e "│ 2  │Alice│"
echo -e "└────┴─────┘"

5. Colors and Styling

ANSI Color Codes

# Color codes
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
BLUE='\033[0;34m'
PURPLE='\033[0;35m'
CYAN='\033[0;36m'
WHITE='\033[0;37m'
NC='\033[0m' # No Color
# Basic colored output
echo -e "${RED}This is red${NC}"
echo -e "${GREEN}This is green${NC}"
echo -e "${BLUE}This is blue${NC}"
# Background colors
BG_RED='\033[41m'
BG_GREEN='\033[42m'
BG_YELLOW='\033[43m'
BG_BLUE='\033[44m'
echo -e "${BG_RED}Red background${NC}"
echo -e "${BG_GREEN}${BLACK}Green background with black text${NC}"
# Text styles
BOLD='\033[1m'
DIM='\033[2m'
UNDERLINE='\033[4m'
BLINK='\033[5m'
REVERSE='\033[7m'
echo -e "${BOLD}Bold text${NC}"
echo -e "${UNDERLINE}Underlined text${NC}"
echo -e "${REVERSE}Reversed colors${NC}"

Practical Color Examples

# Status messages
success() {
echo -e "${GREEN}✓${NC} $1"
}
error() {
echo -e "${RED}✗${NC} $1" >&2
}
info() {
echo -e "${BLUE}ℹ${NC} $1"
}
warning() {
echo -e "${YELLOW}⚠${NC} $1"
}
# Usage
success "Operation completed successfully"
error "File not found"
info "Processing data..."
warning "Low disk space"
# Progress indicator with colors
echo -ne "${CYAN}Processing: ["
for i in {1..10}; do
echo -ne "${GREEN}#${NC}"
sleep 0.2
done
echo -e "${CYAN}] Done!${NC}"
# Colored table
print_colored_table() {
echo -e "${BOLD}${BLUE}ID\tName\tStatus${NC}"
echo -e "${CYAN}1\tAlice\t${GREEN}Active${NC}"
echo -e "${CYAN}2\tBob\t${YELLOW}Pending${NC}"
echo -e "${CYAN}3\tCharlie\t${RED}Inactive${NC}"
}
print_colored_table

6. echo in Scripts

Debugging with echo

#!/bin/bash
# Debug mode
DEBUG=true
debug() {
if [ "$DEBUG" = true ]; then
echo -e "${YELLOW}[DEBUG]${NC} $1" >&2
fi
}
info() {
echo -e "${GREEN}[INFO]${NC} $1"
}
error() {
echo -e "${RED}[ERROR]${NC} $1" >&2
}
# Script with debugging
process_file() {
local file=$1
debug "Processing file: $file"
if [ ! -f "$file" ]; then
error "File not found: $file"
return 1
fi
info "File size: $(stat -c %s "$file") bytes"
debug "File permissions: $(stat -c %a "$file")"
# Process file
while IFS= read -r line; do
debug "Processing line: $line"
echo "Line: $line"
done < "$file"
info "Processing complete"
}
# Call function
process_file "test.txt"
# Trace execution
set -x
echo "This shows command execution"
set +x

Progress Indicators

#!/bin/bash
# Simple spinner
spinner() {
local pid=$1
local delay=0.1
local spinstr='|/-\'
while ps -p $pid > /dev/null 2>&1; do
local temp=${spinstr#?}
printf " [%c]  " "$spinstr"
local spinstr=$temp${spinstr%"$temp"}
sleep $delay
printf "\b\b\b\b\b\b"
done
printf "    \b\b\b\b"
}
# Progress bar
progress_bar() {
local current=$1
local total=$2
local width=50
# Calculate percentage
local percent=$((current * 100 / total))
local filled=$((current * width / total))
local empty=$((width - filled))
# Build bar
printf "\r["
printf "%*s" $filled | tr ' ' '#'
printf "%*s" $empty | tr ' ' '-'
printf "] %d%%" $percent
}
# Usage
echo "Processing with spinner:"
(sleep 3) &
spinner $!
echo -e "\n\nProgress bar:"
for i in {1..100}; do
progress_bar $i 100
sleep 0.05
done
echo

7. Advanced echo Techniques

Here Documents with echo

# Using echo with here documents
cat << EOF
This is a multiline
text block that
preserves formatting.
EOF
# With variable expansion
name="John"
cat << EOF
Hello $name,
This is a message
from the system.
EOF
# Without expansion (quoted delimiter)
cat << 'EOF'
Variable $name will
not be expanded here.
EOF
# With command substitution
cat << EOF
Today is $(date)
Current directory: $(pwd)
EOF
# Indented here document (with tabs)
if true; then
cat <<- EOF
This text is indented
but the leading tabs
are removed.
EOF
fi

echo with Process Substitution

# Compare files
diff <(echo "Line1") <(echo "Line1")
# Process output
while read line; do
echo "Read: $line"
done < <(echo -e "one\ntwo\nthree")
# Multiple process substitutions
paste <(echo -e "1\n2\n3") <(echo -e "A\nB\nC")
# Using with grep
grep "pattern" <(echo -e "line1\npattern line\nline3")

echo and File Operations

# Write to files
echo "First line" > file.txt
echo "Second line" >> file.txt
# Multiple lines to file
{
echo "Line 1"
echo "Line 2"
echo "Line 3"
} > file.txt
# Using tee for both file and stdout
echo "Important message" | tee file.txt
echo "Another message" | tee -a file.txt
# Create configuration files
cat > config.txt << EOF
# Configuration file
host=localhost
port=8080
debug=true
EOF
# Append to file with date
echo "$(date): Script executed" >> log.txt

8. Common Use Cases

Menu and Prompts

#!/bin/bash
# Simple menu
echo "=== Main Menu ==="
echo "1. Display date"
echo "2. List files"
echo "3. Show disk usage"
echo "4. Exit"
echo -n "Choice: "
read choice
case $choice in
1) echo "Date: $(date)" ;;
2) echo "Files: $(ls)" ;;
3) df -h ;;
4) echo "Goodbye!"; exit ;;
*) echo "Invalid choice" ;;
esac
# Confirmation prompt
echo -n "Are you sure? (y/n): "
read answer
if [ "$answer" = "y" ]; then
echo "Proceeding..."
else
echo "Cancelled"
fi
# Multi-line message
echo "╔════════════════════╗"
echo "║   Important Info   ║"
echo "╠════════════════════╣"
echo "║                    ║"
echo "║   Please backup    ║"
echo "║   before running   ║"
echo "║                    ║"
echo "╚════════════════════╝"

Logging Functions

#!/bin/bash
LOG_FILE="app.log"
log() {
local level=$1
local message=$2
local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
echo "[$timestamp] [$level] $message" >> "$LOG_FILE"
# Also show on console for certain levels
case $level in
ERROR)
echo -e "${RED}[ERROR]${NC} $message" >&2
;;
WARN)
echo -e "${YELLOW}[WARN]${NC} $message"
;;
INFO)
echo -e "${GREEN}[INFO]${NC} $message"
;;
esac
}
# Usage
log "INFO" "Application started"
log "INFO" "Loading configuration"
log "WARN" "Using default values"
log "ERROR" "Failed to connect to database"
# Rotate log file
rotate_log() {
if [ -f "$LOG_FILE" ] && [ $(stat -c %s "$LOG_FILE") -gt 1048576 ]; then
mv "$LOG_FILE" "$LOG_FILE.old"
log "INFO" "Log file rotated"
fi
}

Debugging and Tracing

#!/bin/bash
# Function to trace execution
trace() {
echo ">>> $BASH_COMMAND" >&2
}
# Set trap to trace each command
trap trace DEBUG
# Example script
echo "Starting script"
x=5
y=10
sum=$((x + y))
echo "Sum: $sum"
# Turn off tracing
trap - DEBUG
# Conditional debugging
DEBUG=${DEBUG:-0}
debug_echo() {
if [ "$DEBUG" -eq 1 ]; then
echo "DEBUG: $*" >&2
fi
}
debug_echo "Variable x=$x"
debug_echo "Variable y=$y"

9. Performance and Best Practices

Performance Considerations

#!/bin/bash
# Inefficient: Multiple echo calls in loop
time for i in {1..1000}; do
echo "Line $i" >> file.txt
done
# Efficient: Build string in memory first
time {
output=""
for i in {1..1000}; do
output+="Line $i\n"
done
echo -e "$output" > file.txt
}
# More efficient: Use printf for formatting
time {
for i in {1..1000}; do
printf "Line %d\n" "$i"
done > file.txt
}
# Most efficient: Redirect once
time {
for i in {1..1000}; do
echo "Line $i"
done > file.txt
}

Best Practices

#!/bin/bash
# 1. Quote variables to handle spaces
name="John Doe"
echo "Hello, $name"           # Works
echo "Hello, $name"           # Better
# echo Hello, $name           # Problematic if name has spaces
# 2. Use printf for complex formatting
printf "Name: %-20s Age: %3d\n" "$name" 30
# 3. Redirect errors to stderr
echo "Error: File not found" >&2
# 4. Use -n for prompts
echo -n "Enter value: "
read value
# 5. Check if echo supports -e
if [ "$(echo -e)" = "-e" ]; then
echo "echo doesn't support -e"
else
echo -e "Color output supported"
fi
# 6. Avoid using echo for binary data
# Use printf "%b" or cat for binary
printf "\x01\x02\x03" > binary.dat
# 7. Use heredocs for multiline output
cat << EOF > config.txt
# Configuration
key1=value1
key2=value2
EOF

10. Platform Compatibility

Cross-Platform echo

#!/bin/bash
# Detect echo behavior
echo_test() {
if [ "$(echo -n)" = "-n" ]; then
# System V style echo
ECHO_N="echo"
ECHO_C="\c"
else
# BSD style echo
ECHO_N="echo -n"
ECHO_C=""
fi
}
echo_test
# Portable newline handling
$ECHO_N "Loading$ECHO_C"
sleep 1
$ECHO_N ".$ECHO_C"
sleep 1
$ECHO_N ".$ECHO_C"
sleep 1
echo " Done!"
# Portable escape sequences
portable_echo() {
if [ "$(echo -e)" = "-e" ]; then
echo "$1"
else
echo -e "$1"
fi
}
portable_echo "Line1\nLine2"
# Check for color support
if [ -t 1 ]; then
# Terminal supports colors
GREEN='\033[0;32m'
NC='\033[0m'
echo -e "${GREEN}Color output${NC}"
else
# No color support
echo "Plain output"
fi

Environment Detection

#!/bin/bash
# Detect environment
detect_environment() {
if [ -n "$BASH_VERSION" ]; then
echo "Running in Bash $BASH_VERSION"
elif [ -n "$ZSH_VERSION" ]; then
echo "Running in Zsh"
else
echo "Running in unknown shell"
fi
# Check OS
case "$(uname -s)" in
Linux)
echo "OS: Linux"
;;
Darwin)
echo "OS: macOS"
;;
CYGWIN*|MINGW*|MSYS*)
echo "OS: Windows"
;;
*)
echo "OS: Unknown"
;;
esac
}
detect_environment

11. Security Considerations

Safe echo Usage

#!/bin/bash
# Never echo untrusted input directly
user_input="; rm -rf /"  # Malicious input
# Dangerous
echo "User input: $user_input"  # Could be exploited
# Safer
printf "User input: %s\n" "$user_input"
# Use printf for formatting
print_safe() {
printf '%s\n' "$*"
}
print_safe "User input: $user_input"
# Avoid command injection
unsafe() {
echo "Command: $1"
eval $1  # Dangerous!
}
safe() {
echo "Command: $1"
"$@"  # Safer
}
# Handle special characters
special_chars='$VAR `command` "quotes"'
echo "$special_chars"  # Variables expanded
echo '$special_chars'  # Literal string
printf '%s\n' "$special_chars"  # Safe

Logging Security

#!/bin/bash
# Secure logging
LOG_FILE="/var/log/app.log"
secure_log() {
local message="$1"
local timestamp=$(date -Iseconds)
# Sanitize input
message=$(echo "$message" | tr -d '\n\r')
# Log with timestamp
echo "$timestamp $message" >> "$LOG_FILE"
# Set secure permissions
chmod 600 "$LOG_FILE"
}
# Avoid logging sensitive data
log_sensitive() {
local data="$1"
# Mask sensitive data
masked=$(echo "$data" | sed 's/password=[^&]*/password=***/g')
secure_log "API call with $masked"
}

12. Advanced Examples

Interactive Dashboard

#!/bin/bash
# Clear screen
clear
# Print header
echo "╔══════════════════════════════════════╗"
echo "║         System Monitor                ║"
echo "╠══════════════════════════════════════╣"
echo "║ $(date)                ║"
echo "╚══════════════════════════════════════╝"
echo
# System info in columns
{
echo -e "${BOLD}SYSTEM INFO${NC}"
echo "Hostname: $(hostname)"
echo "Kernel: $(uname -r)"
echo "Uptime: $(uptime | cut -d, -f1)"
} | column -t -s ':'
echo
# CPU and Memory
echo -e "${BOLD}RESOURCE USAGE${NC}"
echo "CPU Load: $(uptime | awk -F'load average:' '{print $2}')"
echo "Memory: $(free -h | awk '/^Mem:/ {print $3 "/" $2}')"
echo "Disk: $(df -h / | awk 'NR==2 {print $3 "/" $2 " (" $5 ")"}')"
echo
# Process monitoring
echo -e "${BOLD}TOP PROCESSES${NC}"
ps -eo pid,user,%cpu,%mem,cmd --sort=-%cpu | head -5
echo
# Network info
echo -e "${BOLD}NETWORK${NC}"
ip -4 addr show | grep -oP '(?<=inet\s)\d+(\.\d+){3}' | while read ip; do
echo "  IP: $ip"
done
# Refresh every 5 seconds
if [ "$1" = "--watch" ]; then
while true; do
sleep 5
clear
$0  # Recursive call (simplified)
done
fi

Form Generator

#!/bin/bash
# Function to create a form
create_form() {
local title=$1
shift
local fields=("$@")
local data=()
echo "╔════════════════════════════════════╗"
echo "║     $title"
echo "╠════════════════════════════════════╣"
for field in "${fields[@]}"; do
echo -n "║ $field: "
read value
data+=("$value")
done
echo "╚════════════════════════════════════╝"
# Display summary
echo
echo "Summary:"
for i in "${!fields[@]}"; do
echo "  ${fields[$i]}: ${data[$i]}"
done
}
# Create user registration form
create_form "User Registration" \
"Name" \
"Email" \
"Age" \
"Country"
# Form with validation
validated_form() {
local field=$1
local value=""
while [ -z "$value" ]; do
echo -n "Enter $field: "
read value
if [ -z "$value" ]; then
echo "  $field cannot be empty!"
fi
done
echo "$value"
}
name=$(validated_form "Name")
email=$(validated_form "Email")
echo "Registration complete for: $name ($email)"

Progress Tracker

#!/bin/bash
# Multi-step process tracker
steps=("Initializing" "Processing" "Validating" "Saving" "Cleaning up")
current=0
total=${#steps[@]}
draw_tracker() {
clear
echo "╔══════════════════════════════════════╗"
echo "║         Progress Tracker              ║"
echo "╠══════════════════════════════════════╣"
for i in "${!steps[@]}"; do
if [ $i -lt $current ]; then
echo -e "║  ${GREEN}✓${NC} ${steps[$i]}"
elif [ $i -eq $current ]; then
echo -e "║  ${YELLOW}▶${NC} ${steps[$i]} ${CYAN}(in progress)${NC}"
else
echo "║  ○ ${steps[$i]}"
fi
done
echo "╚══════════════════════════════════════╝"
# Progress bar
percent=$((current * 100 / total))
bar_width=40
filled=$((percent * bar_width / 100))
empty=$((bar_width - filled))
printf "\nProgress: ["
printf "%*s" $filled | tr ' ' '#'
printf "%*s" $empty | tr ' ' '-'
printf "] %d%%\n" $percent
}
# Simulate process
for ((step=0; step<=total; step++)); do
draw_tracker
if [ $step -lt $total ]; then
echo
echo "Working on: ${steps[$step]}..."
sleep 2
fi
current=$step
done
echo -e "\n${GREEN}All steps completed!${NC}"

Conclusion

The echo command is deceptively simple but incredibly versatile:

Key Takeaways

Basic Usage: Simple text output with echo "text"
Options: -n (no newline), -e (escape sequences), -E (no escapes)
Variables: Display with $VAR or ${VAR}
Quoting: Double quotes expand, single quotes literal
Colors: ANSI escape sequences for styled output
Redirection: > (overwrite), >> (append)
Debugging: Use echo to trace script execution
Portability: Be aware of platform differences

Best Practices Summary

Situation	Recommended
Simple text	`echo "text"`
Variables	`echo "Value: $var"`
No newline	`echo -n "prompt: "`
Escape sequences	`echo -e "line1\nline2"`
Complex formatting	`printf`
Error messages	`echo "Error" >&2`
Binary data	`printf` or `cat`
Untrusted input	`printf '%s\n' "$input"`

Common Pitfalls to Avoid

Forgetting to quote variables with spaces
Using echo for binary data
Assuming -e works on all systems
Not redirecting errors to stderr
Using echo in performance-critical loops
Not sanitizing user input

The echo command is your Swiss Army knife for output in Bash. Master it, and you'll write better scripts, debug faster, and create more user-friendly command-line tools.