echo Command - Comprehensive Examples

Overview

The echo command is one of the most fundamental and frequently used commands in Linux. It displays text, variables, and data to standard output (your terminal) or redirects it to files. Despite its apparent simplicity, echo is a powerful tool for shell scripting, debugging, user interaction, and system automation.

Primary Functions:

Display text messages to the terminal
Print shell variable values
Create simple text files
Generate formatted output for scripts
Debug scripts by showing variable values
Provide user feedback during automation
Write data to files via redirection

Built-in vs. External: Echo is typically a shell built-in command (built into bash itself), but there's also an external /usr/bin/echo binary. The built-in version is used by default and is much faster. Use type echo to see which you're using.

Common Options

Option	Description
-n	Do not output the trailing newline (cursor stays on same line)
-e	Enable interpretation of backslash escape sequences
-E	Disable interpretation of backslash escapes (default in most shells)

Escape Sequences (when using -e)

Escape	Description
\n	Newline (line break)
\t	Horizontal tab
\r	Carriage return
\b	Backspace
\a	Alert (bell/beep)
\\	Backslash itself
\c	Suppress trailing newline (similar to -n)
\0NNN	Character with octal value NNN
\xHH	Character with hex value HH

Detailed Examples

Example 1

Basic Text Output

The most fundamental use of echo is displaying simple text messages to the terminal.

                        # Display a simple message
echo Hello, World!

# Display a message with multiple words
echo This is a test message from the echo command
                    

Hello, World! This is a test message from the echo command

Explanation: Echo simply prints whatever text you give it, followed by a newline character. You don't need quotes for simple text, though they're often used for clarity. Multiple spaces between words are collapsed into single spaces unless you use quotes.

Quote Difference:

echo Hello World → "Hello World" (spaces collapsed)
echo "Hello World" → "Hello World" (spaces preserved)

Example 2

Displaying Shell Variables

Echo is commonly used to display the values of shell variables, which is essential for debugging and script output.

                        # Set some variables
USERNAME="craig"
SERVER="web01.binghamton.edu"
PORT=8080

# Display variable values
echo "Current user: $USERNAME"
echo "Server: $SERVER"
echo "Port: $PORT"

# Display environment variables
echo "Your home directory: $HOME"
echo "Current path: $PATH"
echo "Current shell: $SHELL"
                    

Current user: craig Server: web01.binghamton.edu Port: 8080 Your home directory: /home/craig Current path: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin Current shell: /bin/bash

Explanation: The dollar sign $ before a variable name tells the shell to substitute the variable's value. This is one of echo's most common uses - showing what's stored in variables during script execution. Double quotes allow variable expansion, while single quotes would display the literal $USERNAME text.

Pro Tip: Use ${VARIABLE} with curly braces when the variable name needs to be separated from surrounding text: echo "File: ${NAME}_backup.tar"

Example 3

Creating Files with Redirection

Echo combined with output redirection is a quick way to create files or add content to them.

                        # Create a new file with single line
echo "This is the first line" > newfile.txt

# Overwrite (be careful!)
echo "This replaces everything" > newfile.txt

# Append to file (safe)
echo "This is line 1" > myfile.txt
echo "This is line 2" >> myfile.txt
echo "This is line 3" >> myfile.txt

# Display the file
cat myfile.txt
                    

This is line 1 This is line 2 This is line 3

Explanation: The > operator creates a new file (or overwrites an existing one) with echo's output. The >> operator appends to an existing file or creates it if it doesn't exist. This is extremely useful in scripts for creating configuration files, logging events, or building output files incrementally.

Warning: Using > will destroy existing file content without warning! Always use >> to append unless you specifically want to overwrite.

Real-World Use: Scripts commonly use echo with redirection to create simple configuration files, write log entries, or generate reports. For example: echo "$(date): Backup completed successfully" >> /var/log/backup.log

Example 4

Using -n to Suppress Newline

The -n option prevents echo from adding a newline, keeping the cursor on the same line.

                        # Normal echo adds newline
echo "Processing file..."
echo "Done"

# Using -n to stay on same line
echo -n "Enter your name: "
read NAME
echo "Hello, $NAME!"

# Useful for progress indicators
echo -n "Starting backup..."
sleep 2
echo " Done!"
                    

Processing file... Done Enter your name: Craig Hello, Craig! Starting backup... Done!

Explanation: The -n option tells echo not to add the automatic newline at the end. This is perfect for prompts where you want the user's input to appear on the same line, or for creating dynamic status messages that update on a single line. Without -n, the cursor would move to the next line, separating your prompt from the user's input.

Real-World Use: Progress bars, interactive prompts, and status updates in scripts. For example, a backup script might show "Processing file1... Done! Processing file2... Done!" all on one line.

Example 5

Escape Sequences with -e Option

The -e option enables special escape sequences for formatted output including newlines, tabs, and colors.

                        # Multiple lines with \n
echo -e "Line 1\nLine 2\nLine 3"

# Tabs for alignment with \t
echo -e "Name:\tCraig"
echo -e "Server:\tweb01"
echo -e "Status:\tActive"

# Combining escapes
echo -e "Header\n------\nItem 1\nItem 2\nItem 3"

# Bell/alert sound
echo -e "Warning!\a"
                    

Line 1 Line 2 Line 3 Name: Craig Server: web01 Status: Active Header ------ Item 1 Item 2 Item 3 Warning!

Explanation: With the -e option enabled, echo interprets backslash sequences as special characters. \n creates a newline (line break), \t creates a tab for alignment, and \a produces a system beep. This allows you to create formatted output in a single echo command instead of multiple separate echo statements.

Pro Tip: Use \t for columnar output, but for precise alignment across varying data lengths, consider using the column or printf commands instead.

Example 6

Color Output Using ANSI Escape Codes

Echo can display colored text using ANSI escape sequences, making script output more readable and visually organized.

                        # Define color codes
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color (reset)

# Display colored messages
echo -e "${RED}Error: File not found${NC}"
echo -e "${GREEN}Success: Operation completed${NC}"
echo -e "${YELLOW}Warning: Low disk space${NC}"
echo -e "${BLUE}Info: Starting backup process${NC}"

# Colored status messages
echo -e "${GREEN}[OK]${NC} Web server is running"
echo -e "${RED}[FAIL]${NC} Database connection failed"
echo -e "${YELLOW}[WARN]${NC} SSL certificate expires in 7 days"
                    

Error: File not found Success: Operation completed Warning: Low disk space Info: Starting backup process [OK] Web server is running [FAIL] Database connection failed [WARN] SSL certificate expires in 7 days

Explanation: ANSI escape codes (the \033[... sequences) control terminal colors and formatting. The format is \033[ followed by color codes and ending with m. Always reset with ${NC} (No Color) at the end to prevent color bleeding into subsequent output. This makes script output much more readable, with errors in red, successes in green, and warnings in yellow.

Common ANSI Color Codes:

\033[0;30m - Black
\033[0;31m - Red
\033[0;32m - Green
\033[0;33m - Yellow
\033[0;34m - Blue
\033[1;3Xm - Bold (bright) versions (X = color number)
\033[0m - Reset to default

Real-World Use: System monitoring scripts, deployment scripts, and backup utilities use colored output to quickly highlight important information - green for success, red for errors, yellow for warnings.

Example 7

Command Substitution in Echo

Echo can display the output of other commands using command substitution, perfect for dynamic information.

                        # Display current date and time
echo "Current date and time: $(date)"

# Show system information
echo "Hostname: $(hostname)"
echo "Uptime: $(uptime -p)"
echo "Current user: $(whoami)"

# File and directory information
echo "Current directory: $(pwd)"
echo "Files in current directory: $(ls | wc -l)"
echo "Disk usage of /home: $(df -h /home | tail -1 | awk '{print $5}')"

# Process information
echo "Running processes: $(ps aux | wc -l)"

# Network information
echo "IP Address: $(hostname -I | awk '{print $1}')"
                    

Current date and time: Tue Jan 15 14:23:45 EST 2025 Hostname: server01.binghamton.edu Uptime: up 15 days, 7 hours, 23 minutes Current user: craig Current directory: /home/craig/scripts Files in current directory: 47 Disk usage of /home: 68% Running processes: 234 IP Address: 192.168.1.100

Explanation: The $(command) syntax runs the command and substitutes its output into the echo statement. This is incredibly powerful for creating dynamic messages that include real-time system information. The command inside $() is executed first, then its output replaces the $() portion in your echo statement.

Pro Tip: You can also use backticks for command substitution: `command`, but $(command) is preferred because it's easier to read and nest: $(command1 $(command2))

Common Command Substitutions:

$(date +%Y-%m-%d) - ISO format date
$(date +%H:%M:%S) - Current time
$(whoami)@$(hostname) - user@host format
$(cat /proc/cpuinfo | grep processor | wc -l) - CPU count

Example 8

Generating CSV Data

Echo is useful for creating simple CSV (comma-separated values) files for data export or import.

                        # Create CSV header
echo "Hostname,IP Address,Status,Last Check" > servers.csv

# Add data rows
echo "web01,192.168.1.10,Online,2025-01-15" >> servers.csv
echo "web02,192.168.1.11,Online,2025-01-15" >> servers.csv
echo "db01,192.168.1.20,Offline,2025-01-15" >> servers.csv
echo "db02,192.168.1.21,Online,2025-01-15" >> servers.csv

# Generate CSV from variables
HOSTNAME=$(hostname)
IP=$(hostname -I | awk '{print $1}')
STATUS="Online"
DATE=$(date +%Y-%m-%d)

echo "$HOSTNAME,$IP,$STATUS,$DATE" >> servers.csv

# View the CSV
cat servers.csv
                    

Hostname,IP Address,Status,Last Check web01,192.168.1.10,Online,2025-01-15 web02,192.168.1.11,Online,2025-01-15 db01,192.168.1.20,Offline,2025-01-15 db02,192.168.1.21,Online,2025-01-15 server01.binghamton.edu,192.168.1.100,Online,2025-01-15

Explanation: CSV files are just text files with commas separating values. Echo makes it trivial to create these files by printing comma-separated data. This is particularly useful in scripts that need to export data to spreadsheets or other systems that accept CSV input. The first echo creates the header row, and subsequent echoes add data rows.

Real-World Use: System monitoring scripts that track server status, backup scripts that log file sizes and dates, or inventory management scripts that export hardware information to CSV for reporting.

Pro Tip: If your data might contain commas, use a different delimiter like pipe | or tab \t, or wrap fields in quotes: echo "\"$DATA1\",\"$DATA2\""

Example 9

Script Debugging and Status Messages

Echo is essential for debugging scripts by displaying variable values and execution progress.

                        #!/bin/bash
# Backup script with debugging output

BACKUP_DIR="/backup"
SOURCE_DIR="/home/craig/documents"
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="backup_${DATE}.tar.gz"

echo "========================================="
echo "Starting Backup Process"
echo "========================================="
echo ""

echo "Configuration:"
echo "  Source: $SOURCE_DIR"
echo "  Destination: $BACKUP_DIR"
echo "  Filename: $BACKUP_FILE"
echo ""

echo -n "Checking if source directory exists... "
if [ -d "$SOURCE_DIR" ]; then
    echo "OK"
else
    echo "FAILED"
    echo "Error: Source directory not found: $SOURCE_DIR"
    exit 1
fi

echo -n "Checking if backup directory exists... "
if [ -d "$BACKUP_DIR" ]; then
    echo "OK"
else
    echo "Creating backup directory..."
    mkdir -p "$BACKUP_DIR"
fi

echo ""
echo "Creating backup archive..."
tar -czf "$BACKUP_DIR/$BACKUP_FILE" "$SOURCE_DIR" 2>&1

echo ""
echo "Backup completed: $BACKUP_DIR/$BACKUP_FILE"
echo "File size: $(du -h $BACKUP_DIR/$BACKUP_FILE | cut -f1)"
echo "========================================="
                    

========================================= Starting Backup Process ========================================= Configuration: Source: /home/craig/documents Destination: /backup Filename: backup_20250115_142345.tar.gz Checking if source directory exists... OK Checking if backup directory exists... OK Creating backup archive... Backup completed: /backup/backup_20250115_142345.tar.gz File size: 2.3G =========================================

Explanation: This example shows how echo provides crucial feedback during script execution. Status messages tell the user what's happening, configuration details help with debugging, and progress indicators show that the script is working. The combination of regular echo and echo -n creates a professional-looking output with inline status indicators (OK/FAILED).

Pro Tip: Add timestamps to echo statements in long-running scripts: echo "[$(date +%H:%M:%S)] Starting process..." helps track how long each step takes.

Real-World Use: Any production script should include echo statements for status updates, error messages, and completion notices. This makes troubleshooting infinitely easier and gives users confidence that the script is working correctly.

Example 10

Creating Multi-line Configuration Files

Using echo with escape sequences and redirection to create complex multi-line configuration files.

                        # Method 1: Multiple echo commands
echo "[database]" > config.ini
echo "host = localhost" >> config.ini
echo "port = 3306" >> config.ini
echo "user = admin" >> config.ini
echo "" >> config.ini
echo "[logging]" >> config.ini
echo "level = INFO" >> config.ini
echo "file = /var/log/app.log" >> config.ini

# Method 2: Single echo with -e and \n
echo -e "[database]\nhost = localhost\nport = 3306\nuser = admin\n\n[logging]\nlevel = INFO\nfile = /var/log/app.log" > config2.ini

# Method 3: Using variables for dynamic configuration
SERVER="192.168.1.100"
PORT="8080"
APP_NAME="WebApp"

echo -e "# $APP_NAME Configuration" > app.conf
echo -e "# Generated: $(date)\n" >> app.conf
echo -e "[server]" >> app.conf
echo -e "address = $SERVER" >> app.conf
echo -e "port = $PORT" >> app.conf
echo -e "max_connections = 100\n" >> app.conf
echo -e "[security]" >> app.conf
echo -e "ssl_enabled = true" >> app.conf
echo -e "cert_file = /etc/ssl/cert.pem" >> app.conf

# Display the generated file
cat app.conf
                    

# WebApp Configuration # Generated: Tue Jan 15 14:23:45 EST 2025 [server] address = 192.168.1.100 port = 8080 max_connections = 100 [security] ssl_enabled = true cert_file = /etc/ssl/cert.pem

Explanation: This demonstrates three methods for creating configuration files. Method 1 is most readable but verbose. Method 2 is compact but harder to maintain. Method 3 combines readability with the power of variables, making it ideal for generating custom configurations for different environments. The use of variables allows the same script to generate different configs based on runtime parameters.

Note: For complex multi-line content, consider using "here documents" with cat instead: cat > file <<EOF ... EOF. It's often cleaner for large configuration files.

Real-World Use: Deployment scripts that generate server-specific configurations, Docker container initialization scripts that create config files based on environment variables, or automated setup scripts that customize configurations for different environments (dev, staging, production).

Additional Information

Echo vs. Printf:

While echo is simpler, the printf command offers more precise formatting control:

                        # Echo (simple but less control)
echo "User: $USER Balance: $BALANCE"

# Printf (more control, like C's printf)
printf "User: %-10s Balance: %8.2f\n" "$USER" "$BALANCE"
                    

Use echo for simple output, printf when you need specific formatting like decimal places, field widths, or padding.

Quote Usage Guidelines:

No quotes: Simple text without special characters: echo Hello
Double quotes ("..."): When including variables or spaces: echo "User: $USER"
Single quotes ('...'): When you want literal text (no variable expansion): echo 'Cost: $5.00'

Shell Differences:

Echo behavior can vary between shells (bash, sh, zsh, etc.) and between built-in vs. external versions. For portable scripts, consider using printf instead, which has more consistent behavior across shells.

Useful Echo Patterns:

                        # Horizontal line separators
echo "========================================"

# Blank lines for spacing
echo ""

# Error messages to stderr
echo "Error: Operation failed" >&2

# Conditional messages
[ $? -eq 0 ] && echo "Success" || echo "Failed"

# Logging with timestamps
echo "[$(date +'%Y-%m-%d %H:%M:%S')] Event logged" >> /var/log/app.log

# Progress dots
for i in {1..5}; do echo -n "."; sleep 1; done; echo " Done!"

# Box drawing
echo "╔════════════════════╗"
echo "║  System Status     ║"
echo "╚════════════════════╝"
                    

Common Echo Pitfalls to Avoid:

Not quoting variables: echo $VAR can break with spaces. Use echo "$VAR"
Forgetting -e for escapes: echo "Line1\nLine2" prints literally. Use echo -e
Using > instead of >>: Accidentally overwriting files. Be careful with redirectors!
Not resetting colors: Forgetting ${NC} after ANSI codes bleeds color
Echo in command substitution: Usually unnecessary: use variables directly

Performance Note:

In loops with many iterations, repeatedly appending with echo can be slow. For better performance, collect output in a variable or use a temporary file:

                        # Slow (many disk writes)
for i in {1..1000}; do
    echo "Line $i" >> output.txt
done

# Faster (batch write)
OUTPUT=""
for i in {1..1000}; do
    OUTPUT+="Line $i\n"
done
echo -e "$OUTPUT" > output.txt
                    

Quick Reference Card

Task	Command
Display text	`echo "Hello World"`
Display variable	`echo "$VARIABLE"`
No trailing newline	`echo -n "text"`
Enable escape sequences	`echo -e "Line1\nLine2"`
Create file	`echo "content" > file.txt`
Append to file	`echo "content" >> file.txt`
Command substitution	`echo "Date: $(date)"`
Color output	`echo -e "\033[0;31mRed text\033[0m"`
Error to stderr	`echo "Error" >&2`
Blank line	`echo ""` or just `echo`