第169集：错误处理

教学目标

  • 掌握Shell脚本中错误处理的基本概念和方法
  • 学习如何检测和捕获脚本执行过程中的错误
  • 理解不同类型错误的处理策略
  • 掌握错误处理的最佳实践
  • 能够编写健壮的Shell脚本，有效处理各种错误情况

主要知识点

  1. 错误处理的基本概念
  2. 错误的检测方法
  3. 错误的捕获和处理
  4. 错误的退出状态码
  5. 错误的日志记录
  6. 错误的预防和调试
  7. 异常处理机制
  8. 脚本的健壮性设计

实用案例分析

案例1：错误处理的基本概念

目标：了解Shell脚本中错误处理的基本概念和重要性。

操作步骤：

  1. 创建错误处理基本概念演示脚本
# 创建脚本文件
touch error-basics.sh

# 编辑脚本文件
vim error-basics.sh

# 添加以下内容
#!/bin/bash
# 演示错误处理的基本概念

# 1. 错误的产生
echo "=== Error Generation ==="
echo "Trying to access a non-existent file:"
cat non-existent-file.txt
echo "Exit status: $?"

# 2. 退出状态码的含义
echo "\n=== Exit Status Codes ==="
echo "Success (0):"
echo "Hello" > test.txt
echo "Exit status: $?"

echo "\nFailure (non-zero):"
rm non-existent-file.txt
echo "Exit status: $?"

# 3. 错误处理的重要性
echo "\n=== Importance of Error Handling ==="
echo "Script without error handling:"
cat non-existent-file.txt
echo "This line will execute even if the previous command failed"

# 清理测试文件
rm -f test.txt
  1. 运行脚本并查看结果
# 设置执行权限
chmod +x error-basics.sh

# 运行脚本
./error-basics.sh

案例2：错误的检测方法

目标：学习在Shell脚本中检测错误的不同方法。

操作步骤：

  1. 创建错误检测方法演示脚本
# 创建脚本文件
touch error-detection.sh

# 编辑脚本文件
vim error-detection.sh

# 添加以下内容
#!/bin/bash
# 演示错误检测的方法

# 1. 使用 $? 检测错误
echo "=== Using $? to Detect Errors ==="
echo "Trying to access a non-existent file:"
cat non-existent-file.txt
if [ $? -ne 0 ]; then
    echo "Error: Failed to access file"
fi

# 2. 使用 && 和 || 操作符
echo "\n=== Using && and || Operators ==="
echo "Success case:"
mkdir -p test-dir && echo "Directory created successfully"

echo "\nFailure case:"
rmdir non-existent-dir || echo "Error: Directory does not exist"

# 3. 使用 set -e 自动退出
echo "\n=== Using set -e ==="
echo "Script will exit on first error"
set -e
echo "Creating file..."
touch test.txt
echo "Trying to access non-existent file..."
cat non-existent-file.txt
echo "This line will not execute"
set +e

# 4. 使用 set -u 检测未定义变量
echo "\n=== Using set -u ==="
echo "Script will exit on undefined variable"
set -u
echo "Defined variable: $HOME"
echo "Undefined variable: $NON_EXISTENT_VAR"
echo "This line will not execute"
set +u

# 清理测试文件
rm -f test.txt
rm -rf test-dir
  1. 运行脚本并查看结果
# 设置执行权限
chmod +x error-detection.sh

# 运行脚本
./error-detection.sh

案例3：错误的捕获和处理

目标：学习在Shell脚本中捕获和处理错误的方法。

操作步骤：

  1. 创建错误捕获和处理演示脚本
# 创建脚本文件
touch error-handling.sh

# 编辑脚本文件
vim error-handling.sh

# 添加以下内容
#!/bin/bash
# 演示错误的捕获和处理

# 1. 使用 if 语句处理错误
echo "=== Using if Statements ==="
if cat non-existent-file.txt; then
    echo "File accessed successfully"
else
    echo "Error: Failed to access file"
fi

# 2. 使用 trap 命令捕获信号
echo "\n=== Using trap Command ==="
# 定义错误处理函数
error_handler() {
    echo "Error detected at line $LINENO"
    echo "Cleaning up..."
    rm -f temp-file.txt
    exit 1
}

# 设置错误捕获
trap error_handler ERR

echo "Creating temp file..."
touch temp-file.txt
echo "Trying to access non-existent file..."
cat non-existent-file.txt
echo "This line will not execute"

# 清理
rm -f temp-file.txt
  1. 运行脚本并查看结果
# 设置执行权限
chmod +x error-handling.sh

# 运行脚本
./error-handling.sh

案例4：错误的退出状态码

目标：学习Shell脚本中退出状态码的使用和管理。

操作步骤：

  1. 创建退出状态码演示脚本
# 创建脚本文件
touch exit-status.sh

# 编辑脚本文件
vim exit-status.sh

# 添加以下内容
#!/bin/bash
# 演示退出状态码的使用

# 1. 标准退出状态码
echo "=== Standard Exit Status Codes ==="
echo "Success (0):"
exit 0

# 2. 自定义退出状态码
echo "=== Custom Exit Status Codes ==="
# 定义错误类型
ERROR_FILE_NOT_FOUND=1
ERROR_PERMISSION_DENIED=2
ERROR_INVALID_ARGUMENT=3

# 检查参数
if [ $# -eq 0 ]; then
    echo "Error: No arguments provided"
    exit $ERROR_INVALID_ARGUMENT
fi

# 检查文件是否存在
if [ ! -f "$1" ]; then
    echo "Error: File '$1' not found"
    exit $ERROR_FILE_NOT_FOUND
fi

# 检查权限
if [ ! -r "$1" ]; then
    echo "Error: Permission denied for file '$1'"
    exit $ERROR_PERMISSION_DENIED
fi

# 成功处理
echo "File '$1' processed successfully"
exit 0
  1. 运行脚本并查看结果
# 设置执行权限
chmod +x exit-status.sh

# 运行脚本测试不同情况
./exit-status.sh
 echo "Exit status: $?"

./exit-status.sh non-existent-file.txt
 echo "Exit status: $?"

# 创建测试文件并设置权限
 touch test-file.txt
 chmod 000 test-file.txt

./exit-status.sh test-file.txt
 echo "Exit status: $?"

# 恢复权限并测试成功情况
 chmod 644 test-file.txt

./exit-status.sh test-file.txt
 echo "Exit status: $?"

# 清理测试文件
 rm -f test-file.txt

案例5：错误的日志记录

目标：学习在Shell脚本中记录错误日志的方法。

操作步骤：

  1. 创建错误日志记录演示脚本
# 创建脚本文件
touch error-logging.sh

# 编辑脚本文件
vim error-logging.sh

# 添加以下内容
#!/bin/bash
# 演示错误的日志记录

# 定义日志文件
LOG_FILE="script.log"

# 1. 基本日志记录
echo "=== Basic Logging ==="
# 清空日志文件
> "$LOG_FILE"

# 记录信息日志
echo "[$(date '+%Y-%m-%d %H:%M:%S')] INFO: Script started" >> "$LOG_FILE"

# 记录错误日志
echo "Trying to access non-existent file..."
if ! cat non-existent-file.txt; then
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] ERROR: Failed to access non-existent-file.txt" >> "$LOG_FILE"
fi

# 记录成功日志
echo "Creating test file..."
touch test.txt
if [ $? -eq 0 ]; then
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] INFO: Created test.txt successfully" >> "$LOG_FILE"
fi

# 2. 高级日志记录
echo "\n=== Advanced Logging ==="
# 定义日志函数
log_info() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] INFO: $1" >> "$LOG_FILE"
    echo "INFO: $1"
}

log_error() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] ERROR: $1" >> "$LOG_FILE"
    echo "ERROR: $1" >&2
}

log_debug() {
    if [ "$DEBUG" = "true" ]; then
        echo "[$(date '+%Y-%m-%d %H:%M:%S')] DEBUG: $1" >> "$LOG_FILE"
        echo "DEBUG: $1"
    fi
}

# 使用日志函数
log_info "Starting advanced logging example"
log_debug "Debug information"

# 尝试访问不存在的文件
if ! cat another-non-existent-file.txt; then
    log_error "Failed to access another-non-existent-file.txt"
fi

log_info "Script completed"

# 3. 查看日志文件
echo "\n=== Log File Content ==="
cat "$LOG_FILE"

# 清理测试文件
rm -f test.txt "$LOG_FILE"
  1. 运行脚本并查看结果
# 设置执行权限
chmod +x error-logging.sh

# 运行脚本
./error-logging.sh

# 运行脚本并启用调试模式
DEBUG=true ./error-logging.sh

案例6：错误的预防和调试

目标：学习如何预防错误和调试Shell脚本。

操作步骤：

  1. 创建错误预防和调试演示脚本
# 创建脚本文件
touch error-prevention.sh

# 编辑脚本文件
vim error-prevention.sh

# 添加以下内容
#!/bin/bash
# 演示错误的预防和调试

# 1. 错误预防措施
echo "=== Error Prevention ==="

# 检查参数
if [ $# -eq 0 ]; then
    echo "Error: No arguments provided"
    echo "Usage: $0 <filename>"
    exit 1
fi

# 检查文件是否存在
if [ ! -f "$1" ]; then
    echo "Error: File '$1' not found"
    exit 1
fi

# 检查权限
if [ ! -r "$1" ]; then
    echo "Error: Permission denied for file '$1'"
    exit 1
fi

# 2. 调试技巧
echo "\n=== Debugging Techniques ==="

# 方法1：使用 set -x 开启调试模式
echo "\n1. Using set -x:"
set -x
echo "Processing file: $1"
line_count=$(wc -l < "$1")
echo "File has $line_count lines"
set +x

# 方法2：使用 -x 选项运行脚本
echo "\n2. Using bash -x:"
echo "Run: bash -x $0 <filename>"

# 方法3：添加调试输出
echo "\n3. Adding debug output:"
DEBUG=true
if [ "$DEBUG" = "true" ]; then
    echo "Debug: Current directory: $(pwd)"
    echo "Debug: File exists: $([ -f "$1" ] && echo "yes" || echo "no")"
    echo "Debug: File size: $(ls -l "$1" | awk '{print $5}') bytes"
fi

# 3. 防御性编程
echo "\n=== Defensive Programming ==="

# 安全的文件操作
safe_file_operation() {
    local file="$1"
    local operation="$2"
    
    # 检查文件是否存在
    if [ ! -f "$file" ]; then
        echo "Error: File '$file' not found"
        return 1
    fi
    
    # 执行操作
    case "$operation" in
        "read")
            if [ ! -r "$file" ]; then
                echo "Error: Permission denied to read '$file'"
                return 1
            fi
            cat "$file"
            ;;
        "delete")
            if [ ! -w "$file" ]; then
                echo "Error: Permission denied to delete '$file'"
                return 1
            fi
            rm "$file"
            echo "File '$file' deleted"
            ;;
        *)
            echo "Error: Invalid operation '$operation'"
            return 1
            ;;
    esac
    
    return 0
}

# 使用安全文件操作函数
echo "\nUsing safe file operation:"
safe_file_operation "$1" "read"
safe_file_operation "non-existent-file.txt" "read"

# 清理测试文件
rm -f test-file.txt
  1. 运行脚本并查看结果
# 设置执行权限
chmod +x error-prevention.sh

# 创建测试文件
 echo "Line 1"
 echo "Line 2"
 echo "Line 3" > test-file.txt

# 运行脚本
./error-prevention.sh test-file.txt

# 运行脚本并开启调试模式
bash -x ./error-prevention.sh test-file.txt

# 清理测试文件
 rm -f test-file.txt

案例7：异常处理机制

目标：学习Shell脚本中的异常处理机制。

操作步骤：

  1. 创建异常处理机制演示脚本
# 创建脚本文件
touch exception-handling.sh

# 编辑脚本文件
vim exception-handling.sh

# 添加以下内容
#!/bin/bash
# 演示异常处理机制

# 1. 使用 trap 命令捕获异常
echo "=== Using trap for Exception Handling ==="

# 定义异常处理函数
exception_handler() {
    local exit_code=$?
    echo "Exception caught! Exit code: $exit_code"
    echo "Cleaning up resources..."
    # 清理临时文件、关闭连接等
    rm -f temp-file.txt
    echo "Exception handled. Exiting..."
    exit $exit_code
}

# 设置异常捕获（捕获 ERR 信号）
trap exception_handler ERR

# 设置异常捕获（捕获 INT 信号，即 Ctrl+C）
trap 'echo "Interrupted by user"; exit 1' INT

# 2. 模拟异常情况
echo "\n=== Simulating Exceptions ==="

# 模拟文件操作异常
echo "Creating temp file..."
touch temp-file.txt

echo "Simulating file not found error..."
cat non-existent-file.txt

echo "This line will not execute due to exception"

# 清理
rm -f temp-file.txt
  1. 运行脚本并查看结果
# 设置执行权限
chmod +x exception-handling.sh

# 运行脚本
./exception-handling.sh

# 运行脚本并尝试中断
./exception-handling.sh
# 按 Ctrl+C 中断

案例8：脚本的健壮性设计

目标：学习如何设计健壮的Shell脚本。

操作步骤：

  1. 创建健壮性设计演示脚本
# 创建脚本文件
touch robust-script.sh

# 编辑脚本文件
vim robust-script.sh

# 添加以下内容
#!/bin/bash
# 演示脚本的健壮性设计

# 1. 设置脚本选项
set -euo pipefail

# 2. 定义变量和常量
readonly SCRIPT_NAME="$(basename "$0")"
readonly LOG_FILE="${SCRIPT_NAME}.log"
readonly TEMP_DIR="/tmp/${SCRIPT_NAME}.$$"

# 3. 定义函数

# 日志函数
log() {
    local level="$1"
    local message="$2"
    local timestamp="$(date '+%Y-%m-%d %H:%M:%S')"
    echo "[$timestamp] [$level] $message" >> "$LOG_FILE"
    if [ "$level" = "ERROR" ] || [ "$level" = "WARN" ]; then
        echo "$message" >&2
    else
        echo "$message"
    fi
}

# 错误处理函数
error_exit() {
    local message="$1"
    local exit_code="${2:-1}"
    log "ERROR" "$message"
    cleanup
    exit "$exit_code"
}

# 清理函数
cleanup() {
    log "INFO" "Cleaning up resources..."
    if [ -d "$TEMP_DIR" ]; then
        rm -rf "$TEMP_DIR"
        log "INFO" "Removed temporary directory: $TEMP_DIR"
    fi
    log "INFO" "Cleanup completed"
}

# 验证参数
validate_args() {
    if [ $# -ne 1 ]; then
        error_exit "Usage: $SCRIPT_NAME <directory>"
    fi
    
    local dir="$1"
    if [ ! -d "$dir" ]; then
        error_exit "Directory '$dir' not found"
    fi
    
    if [ ! -r "$dir" ]; then
        error_exit "Permission denied to read directory '$dir'"
    fi
    
    log "INFO" "Validated directory: $dir"
    return 0
}

# 处理目录
process_directory() {
    local dir="$1"
    log "INFO" "Processing directory: $dir"
    
    # 创建临时目录
    mkdir -p "$TEMP_DIR" || error_exit "Failed to create temporary directory"
    
    # 统计文件数量
    local file_count=$(find "$dir" -type f | wc -l)
    log "INFO" "Found $file_count files in directory"
    
    # 查找大文件
    log "INFO" "Looking for large files (>1MB)..."
    find "$dir" -type f -size +1M | head -5 >> "$LOG_FILE"
    
    # 查找最近修改的文件
    log "INFO" "Looking for recently modified files..."
    find "$dir" -type f -mtime -1 | head -5 >> "$LOG_FILE"
    
    log "INFO" "Directory processing completed"
}

# 4. 主脚本逻辑
main() {
    # 初始化
    log "INFO" "Starting $SCRIPT_NAME"
    log "INFO" "Script arguments: $*"
    
    # 设置信号捕获
    trap cleanup EXIT
    trap 'error_exit "Script interrupted by user"' INT TERM
    
    # 验证参数
    validate_args "$@"
    
    # 处理目录
    process_directory "$1"
    
    # 完成
    log "INFO" "$SCRIPT_NAME completed successfully"
    exit 0
}

# 5. 运行主函数
main "$@"
  1. 运行脚本并查看结果
# 设置执行权限
chmod +x robust-script.sh

# 运行脚本测试
./robust-script.sh /tmp

# 查看日志
cat robust-script.sh.log

# 测试错误情况
./robust-script.sh non-existent-directory

# 清理
rm -f robust-script.sh.log

课后练习

  1. 基础练习

    • 创建一个脚本，检查指定文件是否存在，并处理各种错误情况
    • 编写一个脚本，使用退出状态码表示不同的错误类型
    • 设计一个简单的日志系统，记录脚本的执行情况和错误信息

  2. 进阶练习

    • 创建一个脚本，使用 trap 命令捕获和处理不同类型的信号
    • 编写一个健壮的文件处理脚本，能够处理文件不存在、权限不足等错误
    • 设计一个脚本，使用调试模式输出详细的执行信息

  3. 挑战练习

    • 创建一个完整的备份脚本，包含错误处理、日志记录和清理功能
    • 编写一个脚本，能够检测和处理网络连接错误
    • 设计一个脚本，使用防御性编程技术处理各种异常情况

总结

本集详细介绍了Linux Shell脚本中的错误处理方法，包括错误的基本概念、检测方法、捕获和处理、退出状态码、日志记录、预防和调试、异常处理机制以及脚本的健壮性设计等内容。通过学习这些知识，读者可以编写更加健壮和可靠的Shell脚本，有效处理各种错误情况。

错误处理是Shell脚本编程中的重要组成部分，它不仅可以提高脚本的可靠性和稳定性，还可以提高脚本的可维护性和可调试性。掌握错误处理技巧是编写专业级Shell脚本的必备技能。

通过本集的学习，读者应该能够理解和使用基本的错误处理方法，掌握错误的检测和捕获技巧，理解不同类型错误的处理策略，以及学习脚本的健壮性设计原则。这些知识将为后续学习脚本调试打下基础，同时也是编写高质量Shell脚本的重要保障。

« 上一篇 文件操作 下一篇 » 脚本调试
↑