Bash Script – Debugging Techniques

Bash scripting is a powerful way to automate tasks and streamline processes on Linux and Unix-based systems. However, even experienced scriptwriters encounter errors and unexpected behavior in their scripts from time to time. This is where debugging comes in handy. Debugging is the process of identifying, diagnosing, and fixing issues in your Bash scripts.

In this blog post, we’ll dive deep into debugging techniques for Bash scripting, aimed at both beginners and experienced scriptwriters. We’ll explore various tools and practices that can help you pinpoint and resolve errors in your scripts effectively. From enabling debugging mode with set -x to halting script execution on errors using set -e, we’ll cover essential debugging practices and provide real-world examples to illustrate their use.

Whether you’re new to Bash scripting or looking to enhance your debugging skills, this article will equip you with the knowledge and tools needed to troubleshoot and fine-tune your Bash scripts, making them more robust and reliable. So, let’s roll up our sleeves and get ready to master the art of debugging in Bash scripting!

Enabling Debugging Mode with set -x

Debugging is like turning on a light in a dark room. It helps us see what’s happening inside our Bash scripts. One essential tool for this is set -x. In this section, we’ll explore what set -x does, how to use it, and why it’s super helpful.

What is set -x and Why Do We Need It?

set -x is like a special pair of glasses for your script. It makes your script talk to you by showing each step it takes.

Imagine your script as a storybook, and set -x is the narrator, telling you what happens on each page.

When you enable set -x, your script becomes chatty, revealing every command it runs and the values of variables. This makes it easier to spot errors and understand what’s going wrong.

How to Enable Debugging Mode with set -x

To turn on the debugging mode, simply add set -x at the beginning of your Bash script.

It’s like saying, “Hey, script, I want to see what you’re doing, so talk to me!”

Here’s how it looks in your script:

set -x  # Enable debugging
# Your script commands go here

Practical Examples

Let’s say you have a script that’s not giving you the expected output. By adding set -x, you can see what’s causing the issue.

For instance, if you have a script that’s supposed to add two numbers:

set -x  # Enable debugging
result=$((num1 + num2))
echo "The result is $result"

When you run this script, you’ll see a detailed log of what’s happening behind the scenes. It might look like this:

+ num1=5
+ num2=7
+ result=12
+ echo 'The result is 12'
The result is 12

With this, you can quickly spot if, for example, num1 had a typo and was set to the wrong value.

Benefits of Using set -x

set -x is like a detective tool. It helps you track down issues in your script.

It saves you time by showing you exactly where something went wrong, so you don’t have to guess.

You can understand your script better by seeing its step-by-step execution.

Debugging becomes less frustrating because you have a clear trail to follow.

Enabling debugging with set -x is like turning on the lights in a dark room. It illuminates your script’s actions, making it easier to catch mistakes and make your scripts work as intended. So, don’t forget to use this handy tool when you’re on a quest to debug your Bash scripts!

Halting Script Execution on Error with set -e

In our journey of understanding Bash script debugging, we’ve got another useful tool in our toolbox: set -e. This tool helps us spot errors early and prevents our script from continuing when something goes wrong.

What is set -e and Why is it Important?

Imagine you’re following a recipe, and if you make a mistake, the recipe book just closes itself. That’s what set -e does for your script.

set -e stands for “exit on error.” When it’s enabled, your script will stop running as soon as it encounters an error, just like our recipe book example.

It’s crucial because it prevents your script from doing further damage when something goes wrong, helping you catch and fix errors early.

How to Enable Error Checking with set -e

To turn on error checking, add set -e at the beginning of your Bash script, just like we did with set -x.

Here’s how it looks in your script:

set -e  # Enable error checking
# Your script commands go here

Common Scenarios Where set -e Helps

set -e is like a guardian angel that watches over your script. It’s particularly helpful in these situations:

  • Command Failures: If a command inside your script fails (returns a non-zero exit code), set -e will stop the script immediately.
  • Undefined Variables: If your script uses a variable that hasn’t been defined, it will also trigger set -e to halt execution.
  • Piping Failures: If a command in a pipeline fails, set -e will catch it and stop the script.

Without set -e, your script might continue running even after an error, potentially causing more problems.

Best Practices for Using set -e Effectively

Use set -e early in your script, preferably right after the shebang line (#!/bin/bash).

Document your scripts well, so you can easily identify which part of the script might trigger set -e.

When you expect a command to fail and want the script to continue despite the error, you can use || true. For example:

set -e
# This command might fail, but we want the script to continue
some_command_that_might_fail || true

Enabling error checking with set -e is like having a safety net for your Bash scripts. It helps you catch issues early, ensuring that your scripts behave as expected and minimizing the chances of causing unintended problems. So, remember to use set -e when you want to keep your scripts on the right track!

Debugging with echo Statements

Sometimes, debugging doesn’t require fancy tools or complex techniques. In Bash scripting, one of the simplest and most effective ways to debug your scripts is by using echo statements. In this section, we’ll explore how to use echo for debugging, where to place these statements, and some helpful tips to make your debugging journey smoother.

What Are echo Statements and How Can They Help?

Think of echo as your script’s way of talking to you. It’s like leaving notes for yourself to understand what’s happening inside your script.

You use echo to print messages or variable values to the terminal. By strategically placing echo statements, you can see how your script progresses and identify issues.

It’s like having signposts in your script, guiding you through its execution.

Where to Place echo Statements in Your Script

Place echo statements at critical points in your script where you want to see what’s happening. This could be before or after important commands or during condition checks.

For example, if you have a script that calculates something, you can use echo to show the values before and after the calculation:


echo "Before calculation: num1=$num1, num2=$num2"

result=$((num1 + num2))

echo "After calculation: result=$result"

Tips for Formatting and Customizing echo Output

Make your echo messages descriptive and clear so you know what each message represents.

Use variables within your echo statements to display variable values, making it easier to track changes.

You can format your echo output with line breaks, tabs, or separators to make it more organized.

Real-World Examples of Debugging with echo Statements

Let’s say you have a script that’s supposed to download files from a list of URLs, but it’s not working as expected. By adding echo statements, you can see which URLs are causing the problem:


urls=("" "" "")

for url in "${urls[@]}"; do
    echo "Downloading file from $url"
    wget "$url"
    if [ $? -eq 0 ]; then
        echo "Download successful: $url"
        echo "Download failed: $url"

With these echo messages, you can quickly spot that the third URL is invalid and causing the download to fail.

Debugging with echo statements is like leaving breadcrumbs in the forest; they help you find your way back if you get lost. It’s a simple yet effective method for understanding and fixing issues in your Bash scripts. So, don’t hesitate to use echo as your script’s trusty sidekick on your debugging adventures!

Using Conditional Statements for Debugging

Conditional statements, like if and while, are not just for making decisions in your Bash scripts. They can also be powerful tools for debugging. In this section, we’ll explore how to employ conditional statements for debugging purposes, write conditional checks to identify script issues, and use them to implement error-handling routines within your scripts. We’ll also provide practical examples to illustrate how conditional statements can assist in debugging.

Leveraging Conditional Statements for Debugging

Conditional statements are like detectives in your script, investigating conditions and helping you find problems.

You can use if statements to check conditions and execute specific code blocks when certain criteria are met.

while loops can be used to repeat a set of actions until a condition is no longer true, which is handy for continuous testing.

Writing Conditional Checks to Identify Script Issues

Think of conditional checks as magnifying glasses. They help you zoom in on specific parts of your script to see if something is wrong.

For example, you can use an if statement to check if a file exists before attempting to read or manipulate it. If the file doesn’t exist, you can display an error message.

Implementing Error-Handling Routines

Error-handling routines are like safety nets for your script. They catch errors before they cause bigger issues.

You can use if statements to detect errors and respond appropriately. For instance, if a required command fails to execute, you can use if to handle the error gracefully and provide feedback.

Practical Examples of Debugging Using Conditional Statements

Let’s say you have a script that processes files in a directory. You want to ensure that the directory exists before proceeding:



if [ ! -d "$target_dir" ]; then
    echo "Error: The target directory does not exist."
    exit 1

# Continue with the script if the directory exists
# ...

In this example, the if statement checks if the directory exists (-d). If not, it displays an error message and exits the script.

Conditional statements are like the Sherlock Holmes of your script, helping you uncover mysteries and fix issues. By employing them strategically, you can make your scripts smarter and more resilient.


In the world of Bash scripting, debugging is your trusty companion on the journey to creating reliable and error-free scripts. We’ve explored some essential debugging techniques that are not only powerful but also accessible to beginners and experienced scriptwriters alike.

  • set -x and set -e: These are like your script’s best friends. They shine a light on the script’s path, making it easier to understand and catch errors. set -x shows every step your script takes, while set -e acts like a guardian, ensuring your script stops when things go wrong.
  • echo Statements: Think of these as notes to yourself within your script. With well-placed echo statements, you can track your script’s progress and see the values of variables, helping you spot issues.
  • Conditional Statements: These are your detectives, checking conditions and revealing script mysteries. You can use if and while statements not only for decision-making but also for debugging. They help you identify problems, implement error-handling routines, and keep your scripts on the right path.

Debugging is not just about fixing errors; it’s about understanding your scripts better and making them more robust. So, the next time you encounter script issues, remember these debugging techniques as your trusted companions on your Bash scripting adventures. With their help, you’ll be well-equipped to conquer any scripting challenge that comes your way. Happy scripting!

Frequently Asked Questions (FAQs)

What is Bash scripting?

Bash scripting involves writing scripts (series of commands) in the Bash shell language to automate tasks and perform actions on Unix-based systems like Linux.

Why is debugging important in Bash scripting?

How can I enable debugging mode with set -x?

What does set -e do, and when should I use it?

How do I use echo statements for debugging?

Can you provide an example of using conditional statements for debugging?

What are some best practices for Bash scripting and debugging?

Are there more advanced debugging tools for Bash scripting?

Can I use these debugging techniques in other shell languages, like zsh or sh?

Where can I learn more about Bash scripting and debugging?

Related Articles