Error Handling in Shell Scripts: 3 Practical Examples

Introduction to Error Handling in Shell Scripts

Error handling is a crucial aspect of writing robust shell scripts. It allows you to gracefully manage unexpected issues that may arise during execution, ensuring your scripts run smoothly and providing meaningful feedback when something goes wrong. This can help prevent data loss, debugging headaches, and improve the overall user experience. Below are three diverse examples of error handling in shell scripts that demonstrate different approaches and contexts.

Example 1: Basic Exit Status Check

In this example, we will demonstrate a simple yet effective way to handle errors using exit status checks. This method is useful when you want to ensure that a command executed successfully before proceeding to the next step.

Suppose you want to copy a file and report whether the operation was successful or not. You can do this by checking the exit status of the cp command.

#!/bin/bash

## Define the source and destination files
SOURCE_FILE="/path/to/source.txt"
DEST_FILE="/path/to/destination.txt"

## Copy the file
cp "\(SOURCE_FILE" "\)DEST_FILE"

## Check if the cp command was successful
if [ $? -eq 0 ]; then
    echo "File copied successfully."
else
    echo "Error: File copy failed." >&2
    exit 1
fi

In this snippet, we use $? to check the exit status of the cp command. If it returns 0, the copy was successful; otherwise, we print an error message and exit with a non-zero status.

Example 2: Using Trap to Handle Errors

This example showcases the use of the trap command to handle errors in a more structured way. This is particularly useful in scripts that have multiple potential failure points.

Imagine a script that processes multiple files and needs to ensure cleanup actions are taken if any command fails. We can use trap to catch errors and execute a cleanup function.

#!/bin/bash

## Function to handle cleanup
cleanup() {
    echo "Cleaning up..."
    rm -f /tmp/tempfile.txt
}

## Set trap to call cleanup on any error
trap 'cleanup; exit 1' ERR

## Simulate file processing
for FILE in /path/to/files/*; do
    echo "Processing $FILE..."
#    # Simulate a potential error
    cat "$FILE" > /tmp/tempfile.txt
done

echo "All files processed successfully."

In this example, if any command within the loop fails, the trap will invoke the cleanup function, ensuring that temporary files are deleted before the script exits.

Example 3: Validating Input Parameters

In this final example, we will validate input parameters to ensure our script runs with the correct arguments. This is a common requirement for scripts that depend on user input.

Consider a script that requires a filename as an argument. We will check if the argument is provided and if the file exists before proceeding.

#!/bin/bash

## Check for input parameter
if [ $# -ne 1 ]; then
    echo "Usage: $0 <filename>" >&2
    exit 1
fi

## Assign the input parameter to a variable
FILENAME="$1"

## Check if file exists
if [ ! -f "$FILENAME" ]; then
    echo "Error: File '$FILENAME' not found." >&2
    exit 1
fi

## Proceed with processing the file
echo "Processing file: $FILENAME"
## (Processing logic goes here)

In this script, we first check the number of arguments passed using $#. If the user does not provide the required filename, we print a usage message and exit. Next, we verify if the specified file exists, ensuring that we do not attempt to process a non-existent file.

By incorporating these examples of error handling in shell scripts, you can ensure that your scripts are more robust and user-friendly. Whether it’s checking command success, using traps for cleanup, or validating input, these practices can significantly improve the reliability of your shell scripting.