How do you handle errors and exceptions in a shell script?

When handling errors and exceptions in Shell scripts, several common strategies can ensure the robustness and reliability of the script. These methods include:

1. Setting Error Handling Options

• Using the set command: At the beginning of the script, use set -e, which causes the script to exit immediately upon encountering an error. This prevents error propagation and cascading failures.
• Using set -u: This option causes the script to exit when attempting to use an undefined variable, helping to catch spelling errors or uninitialized variables.
• Using set -o pipefail: This option causes the entire pipeline command to return a failure status if any subcommand fails. This is highly valuable for debugging complex pipeline commands.

2. Checking Command Return Status

• Using the $? variable: Each Shell command returns a status code upon completion; checking the value of $? reveals whether the previous command succeeded (0 for success, non-zero for failure).
• Conditional statements: For example, you can implement it as follows:

bash
command
if [ $? -ne 0 ]; then
  echo "Command execution failed"
  exit 1
fi

3. Using Exception Handling Mechanisms

• Function encapsulation and exception handling: Encapsulate potentially error-prone code within a function, then check its execution status after the function call to decide whether to proceed or handle errors.
• trap command: The trap command allows defining code to handle errors and clean up resources within the script. For instance, you can capture script interruption (Ctrl+C) or execute specific cleanup commands upon script termination.

bash
trap "echo 'Script interrupted'; exit;" INT
trap "echo 'Performing cleanup'; cleanup_function;" EXIT

4. Clear Error Messages and Logging

• Custom error messages: Provide clear and actionable error messages when errors occur to help users or developers quickly identify issues.
• Logging: Utilize tools like logger or simple redirection to record execution details for subsequent analysis and debugging.

Example

Suppose we have a script for backing up a database; we can enhance error handling as follows:

bash
#!/bin/bash

set -euo pipefail

backup_database() {
  pg_dump -U username dbname > dbname_backup.sql
  if [ $? -ne 0 ]; then
    echo "Database backup failed"
    return 1
  fi
  echo "Database backup successful"
}

trap "echo 'Script interrupted, performing cleanup'; exit 1" INT
trap "echo 'Execution ended, cleaning temporary files'" EXIT

backup_database || exit 1

By employing these techniques, error handling in Shell scripts becomes more reliable, maintainable, and user-friendly.