练习：编写健壮代码与错误处理

以下练习将帮助你实践Julia中错误处理的基础知识，包括try-catch块、finally子句，以及如何定义自己的错误类型。通过这些示例，你将更有信心预测和管理Julia程序中可能出现的问题。

场景 1: 处理无效用户输入

意料之外的用户输入是常见的错误源。想象一个程序，它询问用户的年龄。如果用户输入“thirty”而不是“30”，那么当我们尝试直接将此文本转换为数字时，程序可能会崩溃。让我们看看try-catch如何防止这种情况。

function get_user_age()
    println("Please enter your age: ")
    input_str = readline()
    age_value = -1 # 默认无效年龄

    try
        parsed_age = parse(Int, input_str)
        if parsed_age < 0
            # 对于无效（但可解析）的输入，我们也可以抛出错误
            error("Age cannot be negative.")
        elseif parsed_age > 150 # 一个简单的上限检查
             error("Age seems unusually high. Please re-enter.")
        end
        age_value = parsed_age
        println("Thank you. Your age is: ", age_value)
    catch e
        if isa(e, ArgumentError)
            println("Invalid input: '", input_str, "' is not a whole number. Please enter a numeric value for your age.")
        elseif isa(e, ErrorException) # 捕获由 error() 抛出的错误
            println("Validation error: ", e.msg)
        else
            println("An unexpected error occurred: ", sprint(showerror, e)) # 更详细的错误
        end
        println("Could not determine age due to an input issue.")
    end
    # 在实际函数中，你可能返回 age_value 或一个状态指示器
end

# 让我们尝试调用它
get_user_age()

在此示例中：

• 我们使用 readline() 从用户那里获取字符串输入。
• try块尝试将输入字符串 parse 为 Int。它还包含对合理年龄范围的检查，如果检查失败，则抛出 ErrorException。
• 如果 parse 失败（例如，输入是“hello”），它会抛出 ArgumentError。我们的 catch e 块会拦截它。
• 我们使用 isa(e, ArgumentError) 检查捕获的错误 e 是否是 ArgumentError 类型。这使我们能够为解析失败提供有针对性的消息。
• 如果触发了我们的自定义 error() 调用（例如负年龄），则会抛出 ErrorException。我们使用 isa(e, ErrorException) 捕获此错误并通过 e.msg 显示其消息。
• catch 块的 else 部分是任何其他意外错误的备用处理，使用 sprint(showerror, e) 获取描述性消息。

尝试运行 get_user_age() 并输入 25、abc、-5 或 200 等各种值，以查看不同的 catch 条件如何响应。

场景 2: 带有 finally 的文件操作

当处理文件等外部资源时，即使操作过程中发生错误，也要确保它们被正确释放（例如，关闭）。finally子句非常适合此目的，它确保清理代码的执行。

function process_file_safely(filepath::String)
    io = nothing # 在 try 块外部初始化 'io'，以确保它在 finally 块中可见
    try
        println("Attempting to open file: ", filepath)
        io = open(filepath, "r") # 以读模式打开
        println("File '", filepath, "' opened successfully.")

        println("Processing file content...")
        line_number = 0
        for line in eachline(io)
            line_number += 1
            println("Read line ", line_number, ": ", line)
            # 模拟处理过程中的错误以进行演示
            if line_number == 1 && rand() < 0.7 # 第一行有 70% 的概率出错
                error("Simulated error during file processing!")
            end
        end
        println("File processing complete.")

    catch e
        println("An error occurred while processing '", filepath, "':")
        println(sprint(showerror, e)) # 显示具体错误（例如 SystemError, ErrorException）
    finally
        if io !== nothing && isopen(io) # 检查 'io' 是否已成功赋值且已打开
            println("Closing file '", filepath, "'.")
            close(io)
        elseif io === nothing && !isfile(filepath)
            # 这种情况表示 open() 可能因为文件不存在而失败。
            # 'io' 仍将是 'nothing'。
            println("File '", filepath, "' could not be opened (e.g., does not exist or no permissions).")
        else
            # 这种情况可能是 open() 因其他原因失败，或者我们到达这里时 'io' 不是一个已打开的流。
            println("File '", filepath, "' was not open or already closed; no action needed in finally.")
        end
    end
end

# 创建一个测试用的虚拟文件
open("mydata.txt", "w") do f
    write(f, "Hello Julia\n")
    write(f, "Error Handling Practice\n")
    write(f, "Ensure resources are managed\n")
end

println("--- 处理现有文件（可能触发模拟错误）---")
process_file_safely("mydata.txt")
println("\n--- 尝试处理不存在的文件 ---")
process_file_safely("nonexistentfile.txt") 

# 为了更可靠地看到模拟错误，你可能需要多次运行第一次调用。
# 例如:
# for _ in 1:3 process_file_safely("mydata.txt"); println("---") end

# 清理虚拟文件
if isfile("mydata.txt")
    rm("mydata.txt")
end

这是正在发生的情况：

• 我们将 io 初始化为 nothing。这很重要，因为如果 open() 本身失败（例如文件未找到），io 将不会被赋值为流对象。finally 块需要处理这种情况。
• try块尝试打开并处理文件。我们包含了一个条件 error() 调用来模拟文件读取循环中的失败。
• catch 块处理 try 块内发生的任何错误，例如文件不存在时的 SystemError，或我们模拟的 ErrorException。
• finally 块很重要。无论是否发生错误，它都会执行。
• 在 finally 内部，if io !== nothing && isopen(io) 检查文件是否已成功打开并仍然打开，然后才尝试 close(io)。这可以防止在 open() 失败或文件因某种原因已关闭时出现错误。

这种模式确保文件句柄等资源得到正确管理。然而，Julia 提供了一种更符合习惯的文件处理方式，通常可以简化这一点：

使用带有 do 块的 open

带有 open 的 do 块语法会自动处理文件的关闭，使代码更简洁、更不易出错。

function process_file_with_do(filepath::String)
    try
        # 'do' 块确保 'io' 自动关闭
        open(filepath, "r") do io 
            println("File '", filepath, "' opened successfully (using do block).")
            println("Processing file content (do block)...")
            line_number = 0
            for line in eachline(io)
                line_number += 1
                println("Read line ", line_number, ": ", line)
                if line_number == 1 && rand() < 0.7 # 模拟错误
                     error("Simulated error during file processing (do block)!")
                end
            end
            println("File processing complete (do block).")
        end # 文件 'io' 在此自动关闭，即使内部发生错误。
        println("File operation on '", filepath, "' finished successfully.")
    catch e
        # 这个 catch 块现在处理来自 open() 本身的错误（例如文件未找到）
        # 或来自 'do' 块内部的任何未处理错误。
        println("An error occurred with '", filepath, "':")
        println(sprint(showerror, e))
    end
}

open("mydata_do.txt", "w") do f
    write(f, "Line one with do\n")
    write(f, "Line two with do\n")
end

println("\n--- 使用 'do' 块处理（可能触发模拟错误）---")
process_file_with_do("mydata_do.txt")
println("\n--- 尝试对不存在的文件使用 'do' 块 ---")
process_file_with_do("another_nonexistent.txt")

if isfile("mydata_do.txt")
    rm("mydata_do.txt")
end

带有 do 块的语法通常是文件操作的首选，因为它更简洁，并且Julia会自动处理资源清理。围绕 open(...) do 结构体的 try-catch 则用于处理文件不存在或 do 块内处理逻辑中未处理的错误等问题。

场景 3: 应用逻辑的自定义错误

有时，内置错误类型对于你的应用程序的独特情况来说不够具体。Julia 允许你定义自定义错误类型来清楚地表示这些情况。

假设我们正在编写一个从账户取钱的函数。如果取款金额超过余额，我们希望发出 InsufficientFundsError 信号。

# 定义一个自定义错误类型
struct InsufficientFundsError <: Exception
    balance::Float64
    amount_requested::Float64
    account_id::String
end

# 自定义错误消息的显示方式
function Base.showerror(io::IO, e::InsufficientFundsError)
    print(io, "InsufficientFundsError for account '", e.account_id, 
          "': Cannot withdraw \$", e.amount_requested, 
          ". Available balance is \$", e.balance, ".")
end

function withdraw_cash(account_id::String, balance::Float64, amount::Float64)
    if amount <= 0
        error("Withdrawal amount must be positive.") # 使用标准的 ErrorException
    end
    if amount > balance
        throw(InsufficientFundsError(balance, amount, account_id)) # 抛出我们的自定义错误
    end
    new_balance = balance - amount
    println("Withdrawal of \$", amount, " from account '", account_id, "' successful. New balance: \$", new_balance)
    return new_balance
end

# 让我们试试看
current_balance = 100.0
user_account = "ACC123"

println("--- 尝试有效取款 ---")
try
    current_balance = withdraw_cash(user_account, current_balance, 50.0)
catch e
    println(e) # 如果是 InsufficientFundsError，将使用我们的自定义 showerror
end

println("\n--- 尝试超过余额的取款 ---")
try
    current_balance = withdraw_cash(user_account, current_balance, 200.0)
catch e
    if isa(e, InsufficientFundsError)
        # 'println(e)' 会自动使用我们的自定义 'Base.showerror'
        println("Custom Handling: ", e)
        # 如果需要，我们也可以直接访问字段以进行进一步的逻辑处理：
        # println("Account: ", e.account_id, ", Deficit: ", e.amount_requested - e.balance)
    else
        println("An unexpected error occurred: ", e)
    end
end

println("\n--- 尝试无效取款金额（零）---")
try
    current_balance = withdraw_cash(user_account, current_balance, 0.0)
catch e
    println(e) # 这将是一个 ErrorException
end

让我们分解一下：

1. struct InsufficientFundsError <: Exception: 我们定义了一个新类型 InsufficientFundsError。它是 Exception 的子类型，Exception 是 Julia 中所有异常的基类型。我们的自定义错误存储 balance、amount_requested 和 account_id 以提供上下文。
2. Base.showerror(io::IO, e::InsufficientFundsError): 这是一个可选但强烈推荐的步骤。通过为我们的 InsufficientFundsError 定义一个特定的 Base.showerror 方法，我们自定义了此错误的实例显示方式。这使得调试和用户反馈更加清晰。当你 println(e) 或 REPL 捕获并显示错误时，将使用此方法。
3. throw(InsufficientFundsError(balance, amount, account_id)): 在 withdraw_cash 内部，如果满足资金不足的条件，我们创建一个自定义错误实例（填充其字段），然后 throw 它。
4. catch e with isa(e, InsufficientFundsError): 调用 withdraw_cash 时，我们的 try-catch 块可以专门检查捕获的错误 e 是否为 InsufficientFundsError。这允许更精细的错误管理，将此特定业务逻辑故障与（例如，如果 balance 来自数据库，则可能出现的网络问题等）其他潜在错误区别对待。

自定义错误使你的程序意图更清晰，并能够实现更复杂、应用程序特定的错误处理策略。

场景 4: 优雅降级（模拟）

有时，你程序的部分功能可能依赖于外部服务或可能会失败的操作（例如，网络请求）。与其让整个程序停止运行，你可能希望它以受限功能继续，或者使用默认/缓存数据。这种方法通常被称为优雅降级。

想象一个函数，它尝试从（模拟的）网络服务获取“每日消息”。如果服务不可用，我们将返回一个默认消息而不是让程序崩溃。

# 模拟一个可能失败的函数（例如，网络调用）
function fetch_message_from_external_service()::String
    # 模拟 70% 的失败概率以进行演示
    if rand() < 0.7 
        error("Network service unavailable! Code: SVC503") 
    end
    return "Julia: High performance, dynamic, and fun!" # 成功获取
end

function get_daily_message_with_fallback()
    default_message = "Keep calm and code in Julia. (Default message)"
    final_message = ""
    try
        message_from_service = fetch_message_from_external_service()
        println("Successfully fetched message from service: \"", message_from_service, "\"")
        final_message = message_from_service
    catch e
        # 检查它是否是我们期望的服务特定错误
        if isa(e, ErrorException) && occursin("SVC503", e.msg)
             println("Warning: Could not fetch today's message (Service Error: ", e.msg, "). Using default.")
        else
            println("Warning: An unexpected issue occurred while fetching message (", sprint(showerror,e) ,"). Using default.")
        end
        final_message = default_message
    end
    return final_message
end

# 运行几次以查看两种结果（成功和回退）
println("--- 获取每日消息 ---")
for i in 1:5
    println("\n尝试 ", i, ":")
    displayed_msg = get_daily_message_with_fallback()
    println("显示: \"", displayed_msg, "\"")
end

在此示例中：

• fetch_message_from_external_service() 通过随机抛出一个带有特定消息模式的 ErrorException 来模拟一个可能失败的操作。
• get_daily_message_with_fallback() 在 try 块内调用此服务函数。
• 如果 fetch_message_from_external_service() 成功，则使用其消息。
• 如果失败，catch 块将执行。它不会重新抛出错误或崩溃，而是打印一条警告消息（在实际应用程序中可能会记录错误 e），然后返回一个 default_message。程序继续运行，尽管可能信息不够最新或完整。

这种方法使你的应用程序对其依赖项中的故障更具弹性。如果应用程序能够以某种默认行为继续运行而不是完全停止，用户体验通常会更好。

这些场景涵盖了Julia中错误处理的常见模式。当你编写更多代码时，你将培养出对错误可能发生的位置以及如何最好地管理它们的直觉。请记住，清晰的错误消息、适当的特定错误类型以及明智地使用 finally（或用于资源管理的 do 块）对软件的可靠性和可维护性有显著贡献。

进一步练习建议：

1. 输入循环： 修改 get_user_age 函数，使其持续循环，直到用户提供有效输入（合理范围内的非负整数）。
2. 高级银行账户： 扩展 withdraw_cash 函数。如果存在每日取款限额怎么办？定义并抛出 WithdrawalLimitExceededError。你将如何处理多个账户，也许从字典中读取余额？
3. 文件数据聚合器： 编写一个脚本，尝试读取名为 numbers.txt 的文件。此文件的每一行都应包含一个数字。你的脚本应将所有有效数字求和。
   • 如果 numbers.txt 不存在，打印一条信息性消息并优雅地退出。
   • 如果某行包含非数字文本（例如“hello”而不是“123”），parse 将失败。捕获此 ArgumentError，打印一条警告，指示有问题行号及其内容，跳过该行，然后继续处理文件的其余部分。
   • 即使发生错误，也要确保文件始终关闭。
   • 处理后，打印有效数字的总和以及因错误跳过的行数。