Bash is a powerful tool that can automate repetitive tasks and make your life easier. But with great power comes great responsibility, and one of the most important responsibilities of a bash script is to check for errors.

Error checking is the process of ensuring that your script runs smoothly and does not cause any harm to your system or data. It involves checking for things like missing files, incorrect permissions, and invalid input.

There are several ways to check for errors in a bash script, and in this article, we will explore some of the most common methods.

Exit Codes

One of the most basic ways to check for errors in a bash script is to check the exit code of each command. Every command that is run in a bash script returns an exit code, which is a number that indicates the success or failure of the command.

An exit code of 0 means that the command was successful and did not encounter any errors. Any other number means that an error occurred.

For example, let’s say we have a script that creates a directory:

#!/bin/bash
mkdir my_directory

If the directory is created successfully, the exit code of the mkdir command will be 0. If the directory already exists or if we do not have permission to create the directory, the exit code will be non-zero.

We can check the exit code of a command using the $? variable, which holds the exit code of the last command that was run.

#!/bin/bash
mkdir my_directory
if [ $? -ne 0 ]; then
  echo "An error occurred while creating the directory"
  exit 1
fi

In this example, we are checking the exit code of the mkdir command and, if it is non-zero, we are printing an error message and exiting the script with an exit code of 1.

Using set -e

Another way to check for errors in a bash script is to use the set -e command. This command tells the bash interpreter to exit the script if any command returns a non-zero exit code.

#!/bin/bash
set -e
mkdir my_directory
touch my_directory/file.txt

In this example, if the mkdir command fails, the script will exit immediately and will not execute the touch command.

This can be useful if you have a script that performs multiple tasks and you want to stop execution if any of them fail. However, it can also be dangerous if you are not careful. For example, if a command that is expected to return a non-zero exit code is run, the script will exit prematurely.

You can use set +e to disable the -e option.

Using || and &&

Another way to check for errors in a bash script is to use the || and && operators. These operators allow you to specify a command to run if the previous command fails or succeeds, respectively.

#!/bin/bash
mkdir my_directory || echo "An error occurred while creating the directory"
touch my_directory/file.txt && echo "File created successfully"

In this example, if the mkdir command fails, the echo command will be run and the script will continue to execute the touch command. If the touch command succeeds, the echo command will be run, letting us know that the file was created successfully.

The || and && operators can be useful for running specific commands depending on the success or failure of a previous command. However, they can also be dangerous if you are not careful. For example, if a command that is expected to fail is run, the script will execute the command specified with the || operator, which may not be what you intended.

Using try, catch and finally

Another way to check for errors in a bash script is to use the try, catch, and finally commands. These commands allow you to specify a block of code to run if an error occurs, and a block of code to run regardless of whether an error occurs.

#!/bin/bash
try {
  mkdir my_directory
} catch {
  echo "An error occurred while creating the directory"
} finally {
  echo "The script has completed"
}

In this example, if the mkdir command fails, the catch block will be executed and the error message will be printed. Regardless of whether an error occurred, the finally block will be executed, letting us know that the script has completed.

This method can be useful for catching specific errors and handling them in a specific way, while also providing a way to execute code regardless of whether an error occurred.

Conclusion

Error checking is an important part of bash scripting, and there are several ways to check for errors in a script. Whether you use exit codes, the set -e command, the || and && operators, or the try, catch, and finally commands, it is important to be aware of potential errors and handle them in a way that will protect your system and data.

It is also recommended to use multiple error checking methods in your script to ensure that all possible errors are caught and handled. Remember that it is better to be safe than sorry, so take the time to thoroughly test your script and check for errors before running it in a production environment.