Bash echo Command

Bash echo Command – Displaying Text In Terminal

by

Ever needed your Bash script to ‘talk’ to you, displaying messages, instructions, or results? Or perhaps you just want to quickly print some text to your terminal screen? That’s where the echo command comes in – your voice in the command line!

echo is one of the most fundamental and frequently used Bash commands. It is designed for a singular, yet incredibly powerful, purpose: displaying text strings. Think of it like speaking or printing words directly onto your terminal’s display. It is how your script communicates with you, tells you what is happening, or presents information.

This post is for anyone starting their journey in Linux, those learning shell scripting, or users looking to refine their command-line output. We will explore everything from its simple beginnings to advanced uses in real-world scenarios.

What is echo?

At its core, echo is a built-in shell command. This means it is an intrinsic part of your Bash shell (and other shells like Zsh or Dash). Because it is built-in, it is super fast and always available without needing to search your system’s PATH.

Its main function is to output text (strings of characters) to standard output, which is typically your terminal screen. It can display static text, the values stored in variables, or even the results of other commands. While it seems simple, echo is incredibly versatile and can be used for tasks ranging from displaying basic messages to formatting complex script interactions and debugging.

Basic Usage of echo

Let us start with the basics. You will be amazed at how much you can do with just these fundamental uses.

Simple Text String

This is the echo you will use most often.

Command: 

echo Hello, World!

Explanation: The echo command will print whatever follows it directly to your terminal screen, followed by a new line.

Text with Spaces and Special Characters (Quoted vs. Unquoted)

When your text gets a bit more complex, quoting becomes crucial.

Unquoted Example: 

echo This is a test.

Explanation: For simple phrases without special shell characters, echo works just fine without quotes. However, be careful! If you have characters like *, ?, $, or spaces that the shell might interpret, you will need quotes.

Quoted Example 1 (Double Quotes): 

echo "This is a test with multiple spaces."

Explanation: Double quotes (") preserve all the spaces and characters exactly as you type them. They also allow variable expansion, meaning if you have $MY_VARIABLE inside double quotes, the shell will replace it with the variable’s value.

Quoted Example 2 (Single Quotes): 

echo 'This is another test with *special* characters.'

Explanation: Single quotes (') are the most literal. They preserve everything inside them exactly as typed, preventing any kind of shell expansion, including variable expansion or wildcard interpretation. Use them when you want to print a string exactly as is.

Empty Line

Sometimes, all you need is a bit of breathing room.

Command: 

echo

Explanation: Running echo without any arguments simply prints a blank line to your terminal. This is fantastic for formatting output and improving the readability of your script’s messages.

Understanding echo Options (Flags)

echo becomes much more powerful when you start using its options, also known as flags. These flags modify its default behavior.

-n (No Newline)

By default, echo adds a newline character at the end of its output, which moves your cursor to the beginning of the next line. The -n option changes that.

Explanation: This option tells echo not to add the trailing newline. The cursor will remain at the end of the printed text on the same line.

Example: 

echo -n "Hello, " 
echo "World!"

Expected Output: 

Hello, World! #printed on a single line

-e (Enable Backslash Escapes)

This is where echo really starts to shine for formatted output. Without -e, echo treats backslash characters (\) literally. With -e, it interprets special “escape sequences” that start with a backslash.

Explanation: The -e option enables the interpretation of backslash escapes. These are special character combinations that represent non-printable characters or provide specific formatting instructions.

Common Escape Sequences to Master:

\n (Newline): Forces a line break, moving subsequent text to the next line.

Example: 

echo -e "First line\nSecond line"

Output: 

First line 
Second line

\t (Horizontal Tab): Inserts a tab space for alignment, which is super useful for creating columns.

Example: 

echo -e "Name:\tJohn Doe\nAge:\t30"

Output: 

Name:     John Doe 
Age:    30

\b (Backspace): Moves the cursor one character back. This can be used to overwrite characters.

Example: 

echo -e "Hello World\b\b\b\bEDIT"

Output: 

Hello WEDIT #The World part gets partially overwritten by EDIT

\c (Suppress trailing newline): Stops echo from printing the final newline character, similar to -n. Any characters after \c in the string will not be printed.

Example: 

echo -e "Starting...\c" && echo "Done!"

Output: 

Starting...Done!

\\ (Literal Backslash): Prints an actual backslash character. Useful when you need a \ that is not interpreted as an escape sequence.

Example: 

echo -e "This is a path: C:\\Users\\Public"

Output: 

This is a path: C:\Users\Public

\xHH (Hexadecimal value): Represents an ASCII character using its hexadecimal code (e.g., \x41 for ‘A’). This is more advanced but useful for printing specific characters not easily typed.

Practical echo Scenarios and Examples

Now let us see echo in action with some real-world use cases!

Scenario 1: Displaying Variable Values

echo is your go-to for checking the contents of variables.

USERNAME="Alice"
echo "Welcome, $USERNAME!"

Explanation: When enclosed in double quotes, echo automatically performs variable expansion, replacing $USERNAME with the value “Alice”.

Scenario 2: Displaying Command Output (Command Substitution)

You can use echo to print the result of another command.

echo "Today's date is: $(date)"
echo "Current directory contents: $(ls -lh)"

Explanation: The $() syntax is called command substitution. The command inside the parentheses (date or ls -lh) is executed, and its output replaces the $(...) expression, which echo then displays.

Scenario 3: Creating Simple Prompts/Messages in Scripts

echo is perfect for making your scripts interactive and user-friendly.

echo "Please enter your name below:"
read USER_INPUT
echo "Thank you, $USER_INPUT!"

Explanation: echo is used here to give instructions to the user and then to provide feedback after they have entered their input.

Scenario 4: Adding Blank Lines for Readability

Use echo to visually separate sections of your script’s output.

echo "--- Starting Script ---"
echo
echo "Performing operation A..."
echo
echo "Operation A complete."

Explanation: Simple echo commands without arguments create visual separation, making script output much easier to read and understand, especially for longer processes.

Scenario 5: Writing Text to a File (Redirection)

echo is not just for the screen; it can write to files too!

Overwriting a file:

echo "This is the first line." > my_log.txt

Explanation: The > operator redirects the output of echo from the terminal to my_log.txt. If my_log.txt already exists, its contents are completely overwritten.

Appending to a file:

echo "This is the second line." >> my_log.txt

Explanation: The >> operator appends the output to my_log.txt without deleting any existing content. The new text is added to the end of the file.

Let us see the combined content:

cat my_log.txt

Output:

This is the first line.
This is the second line.

Scenario 6: Displaying Formatted Output with Tabs and Newlines

Combine -e with escape sequences for structured output.

echo -e "Product\tPrice\tIn Stock"
echo -e "Laptop\t$1200\tYes"
echo -e "Mouse\t$25\tYes"

Explanation: Using \t for tabs and \n for newlines (enabled by -e) allows you to create neatly aligned columns or multi-line messages, significantly improving the presentation of data.

Scenario 7: Debugging Scripts (Printing Values at Specific Points)

When a script is not behaving as expected, echo is your best friend for debugging.

item_price=50
quantity=3
total=$((item_price * quantity))

echo "DEBUG: After calculation, total is $total"
# ... rest of script

Explanation: echo is invaluable for printing variable values or progress messages at different stages of a script. By inserting echo "DEBUG: ..." lines, you can trace the flow of your script and see the values of variables at specific points, helping you identify where issues might be occurring.

echo vs. printf (Brief Comparison)

While echo is incredibly useful, you might encounter printf in more advanced or portable scripts. Here is a quick distinction:

  • When to use echo:
    • For simple messages, quick text output, or when you just need to print a variable. It is concise, easy to remember, and perfectly adequate for most day-to-day tasks and simple scripts.
  • When to consider printf:
    • For more complex and precisely formatted output (e.g., aligning columns exactly, formatting numbers, handling specific character encodings, or filling spaces with specific characters). printf behaves more consistently across different shells (Bash, Zsh, Dash), making it a better choice for highly portable scripts that need to run identically everywhere. It is more akin to the printf function in C programming.

Common Pitfalls and Tips

Even with such a straightforward command, there are a few things to keep in mind to avoid unexpected behavior.

  • Quoting is Key:
    • Always remember to use quotes (" or ') around strings, especially those containing spaces, wildcards (*, ?), or special shell characters ($, !).
    • Double quotes (") allow variable expansion (e.g., $MY_VAR) and command substitution ($(command)).
    • Single quotes (') suppress all expansion, printing everything literally.
  • Remember -e for Escapes: Always remember to use the -e option if you intend for echo to interpret backslash escape sequences like \n or \t. Without it, \n will just print as \n.
  • Shell Differences (Minor Note): While echo is widely compatible, its exact behavior with options like -e or -n can sometimes differ slightly between different shells (Bash, Zsh, Dash). For maximum portability in critical scripts that need to run identically across various environments, printf is often recommended as it offers more consistent behavior. For most everyday tasks and Bash scripting, echo is perfectly fine.

You have now mastered echo, one of the most fundamental yet powerful commands in Bash! From simple messages to formatted output and basic file manipulation, you have the tools to make your scripts talk. Keep practicing these examples, and you will find yourself using echo constantly to build clearer, more interactive, and easier-to-debug shell scripts.

What is the first message you are going to make your script echo to the world?

FAQ’s – Linux/Unix Bash Command – echo

What is the echo command in Bash?
The echo command is used to display a line of text or a variable’s value in the terminal. It is frequently used in scripts and command-line operations for outputting information.

How do I print text using the echo command?
Use echo followed by the string you want to print:

echo "Hello, world!"

This prints:

Hello, world!

How do I print the value of a variable using echo?
You can print a variable by prefixing it with $:

name="Alice"
echo "Hello, $name!"

Output:

Hello, Alice!

How do I print multiple lines using echo?
Use the -e flag to enable interpretation of backslash-escaped characters, including \n for newlines:

echo -e "Line 1\nLine 2\nLine 3"

Output:

Line 1
Line 2
Line 3

What does the -e option do in echo?
The -e option enables the interpretation of escape characters like:

  • \n – new line
  • \t – tab
  • \\ – backslash
  • \" – double quote

Example:

echo -e "Tab\tSeparated\tWords"

How do I suppress the trailing newline with echo?
Use the -n option to print without a trailing newline:

echo -n "Hello"

Output:

Hello%   # Cursor stays on the same line

How do I include quotes in the output of echo?
Use escaped quotes or mix single and double quotes:

echo "\"Quoted text\""
# or
echo '"Quoted text"'

Output:

"Quoted text"

How do I print colored text using echo in Bash?
Use ANSI escape codes along with -e. Example for red text:

echo -e "\e[31mThis is red text\e[0m"

Color codes:

  • \e[31m – Red
  • \e[32m – Green
  • \e[33m – Yellow
  • \e[0m – Reset

Can I redirect the output of echo to a file?
Yes. Use the > or >> operators:

echo "Hello" > file.txt    # Overwrites the file
echo "World" >> file.txt   # Appends to the file

How do I use echo in a Bash script?
In a Bash script, use echo just like in the terminal:

#!/bin/bash
echo "This is a Bash script"

Save as script.sh, then run with:

bash script.sh

What is the difference between echo and printf in Bash?

  • echo is simpler and good for basic output.
  • printf offers more formatting control, such as fixed width, floating-point precision, etc.

Example:

printf "Name: %s, Age: %d\n" "Alice" 30

How do I print a backslash (\) using echo?
Escape the backslash with another backslash:

echo -e "This is a backslash: \\"

Output:

This is a backslash: \

Why is echo not printing newlines or tabs as expected?
By default, echo does not interpret escape characters. You need to use -e:

echo -e "First line\nSecond line"

How do I make echo portable across different systems?
Some versions of echo behave differently. To ensure portability:

  • Avoid using -e and use printf instead for complex output.
  • Use echo only for basic text without escape sequences.

Can I use echo to display command output?
You can embed command output using command substitution:

echo "Today is: $(date)"

Output:

Today is: Fri Jul 19 10:00:00 IST 2025

How do I print environment variables using echo?
Use $ before the variable name:

echo $HOME

This prints the current user’s home directory path.

Author

Debjeet Bhowmik

Experienced Cloud & DevOps Engineer with hands-on experience in AWS, GCP, Terraform, Ansible, ELK, Docker, Git, GitLab, Python, PowerShell, Shell, and theoretical knowledge on Azure, Kubernetes & Jenkins. In my free time, I write blogs on ckdbtech.com

Leave a Comment