面试题：Go语言错误处理的多层嵌套与错误传播误区

Question

假设你有一个多层嵌套调用的函数结构，从函数A调用函数B，函数B调用函数C，每个函数都可能返回错误。在处理错误时，常见的误区是错误处理不当导致错误信息丢失或难以追踪。请编写代码示例，展示如何在这种多层嵌套调用中正确传播和处理错误，同时避免常见的错误处理误区。

Answer 1

以下是Python代码示例：

def functionC():
    # 模拟可能出现的错误
    if some_condition:
        raise ValueError("Function C error")
    return "Function C result"

def functionB():
    try:
        result_c = functionC()
        # 处理functionC的结果
        return f"Function B processed: {result_c}"
    except ValueError as e:
        # 这里可以选择记录日志等操作
        raise ValueError(f"Function B caught and re - raised: {e}")

def functionA():
    try:
        result_b = functionB()
        # 处理functionB的结果
        return f"Function A processed: {result_b}"
    except ValueError as e:
        # 最终处理错误
        print(f"Function A caught final error: {e}")


if __name__ == "__main__":
    functionA()

在上述代码中：

1. 错误传播：每个函数如果捕获到内部函数抛出的错误，会重新抛出，带上原错误信息，确保错误信息不会丢失。
2. 避免误区：通过在捕获错误时重新抛出并附带原错误信息，这样在最外层函数处理错误时，可以清晰追踪错误源头。

在其他语言如Java中：

class FunctionC {
    public static String functionC() throws Exception {
        // 模拟可能出现的错误
        if (someCondition) {
            throw new Exception("Function C error");
        }
        return "Function C result";
    }
}

class FunctionB {
    public static String functionB() throws Exception {
        try {
            String resultC = FunctionC.functionC();
            // 处理functionC的结果
            return "Function B processed: " + resultC;
        } catch (Exception e) {
            // 这里可以选择记录日志等操作
            throw new Exception("Function B caught and re - raised: " + e.getMessage(), e);
        }
    }
}

class FunctionA {
    public static void functionA() {
        try {
            String resultB = FunctionB.functionB();
            // 处理functionB的结果
            System.out.println("Function A processed: " + resultB);
        } catch (Exception e) {
            // 最终处理错误
            System.err.println("Function A caught final error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        FunctionA.functionA();
    }
}

在Java代码中同样通过捕获内部函数抛出的异常并重新抛出带有原异常信息的新异常，保证错误信息不丢失且能追踪错误源头。