Golang 编程之旅：搭乘 trycatch 包的错误处理 “过山车”

一、概述

trycatch 包提供了一种类似于其他编程语言中 try - catch - finally 结构的错误处理机制，旨在帮助开发者更方便地处理在代码执行过程中可能出现的错误，并确保在任何情况下都能执行必要的清理操作。这有助于提高代码的健壮性、可读性以及可维护性，使得错误处理逻辑与业务逻辑能够相对清晰地分离。

二、代码示例与详细解释

（一）TryCatch 结构体

type TryCatch struct {
    try     func() error
    catch   func(err error)
    finally func()
}

• 这个结构体是整个 trycatch 包的核心数据结构。它包含三个成员变量：

  • try：是一个无参数且返回 error 类型的函数。开发者将需要尝试执行并可能出错的代码逻辑封装在这个函数中。如果在执行这个函数的过程中发生了错误，该错误将被传递给 catch 函数进行处理（如果 catch 函数已被设置）。
  • catch：是一个接收 error 类型参数的函数。当 try 函数执行出错时，catch 函数会被调用，开发者可以在这个函数中编写针对错误的处理逻辑，例如记录错误日志、进行错误信息的展示或者尝试进行错误恢复操作等。
  • finally：是一个无参数的函数。无论 try 函数执行是否成功（即是否发生错误），finally 函数都会在最后被执行。通常用于执行一些资源清理操作，如关闭文件、释放数据库连接等，以确保程序的资源能够被正确地管理和释放，避免资源泄漏。

（二）New 函数

func New() *TryCatch {
    return &TryCatch{}
}

• New 函数是 trycatch 包对外提供的创建 TryCatch 结构体实例的方法。它简单地返回一个指向新创建的 TryCatch 结构体的指针，此时新实例中的 try、catch 和 finally 函数均未被初始化设置，需要通过后续的方法调用来分别设置它们。

（三）Try 函数（TryCatch 结构体的方法）

func (t *TryCatch) Try(try func() error) *TryCatch {
    t.try = try
    return t
}

• 该方法用于设置 TryCatch 实例中的 try 函数。它接收一个 func() error 类型的参数 try，这个参数就是开发者定义的需要尝试执行的可能出错的函数。在方法内部，将传入的 try 函数赋值给 TryCatch 结构体实例的 try 成员变量，然后返回当前 TryCatch 实例的指针，这样就可以实现链式调用，方便开发者连续地设置 catch 和 finally 函数。

（四）Catch 函数（TryCatch 结构体的方法）

func (t *TryCatch) Catch(catch func(error)) *TryCatch {
    t.catch = catch
    return t
}

• Catch 方法用于设置 TryCatch 实例中的 catch 函数。它接收一个 func(error) 类型的参数 catch，这个参数就是用于处理错误的函数。在方法内部，将传入的 catch 函数赋值给 TryCatch 结构体实例的 catch 成员变量，然后返回当前 TryCatch 实例的指针，以便继续进行链式调用设置 finally 函数。

（五）Finally 函数（TryCatch 结构体的方法）

func (t *TryCatch) Finally(finally func()) *TryCatch {
    t.finally = finally
    return t
}

• Finally 方法用于设置 TryCatch 实例中的 finally 函数。它接收一个 func() 类型的参数 finally，这个参数就是无论如何都会执行的最终操作函数。在方法内部，将传入的 finally 函数赋值给 TryCatch 结构体实例的 finally 成员变量，然后返回当前 TryCatch 实例的指针，至此完成了 try、catch 和 finally 函数的设置，可以进行错误处理流程的执行。

（六）Do 函数（TryCatch 结构体的方法）

func (t *TryCatch) Do() {
    // 检查 try 函数是否已设置，如果未设置则直接返回
    if t.try == nil {
        return
    }
    defer func() {
        // 使用 recover 捕获可能发生的 panic
        if err := recover(); err!= nil {
            // 检查 catch 函数是否已设置，如果设置则调用 catch 函数处理错误
            if t.catch!= nil {
                t.catch(err.(error))
            }
        }

        // 检查 finally 函数是否已设置，如果设置则执行 finally 函数
        if t.finally!= nil {
            t.finally()
        }
    }()

    // 执行 try 函数，如果执行过程中发生错误，则会触发 panic
    err := t.try()
    if err!= nil {
        panic(err)
    }
}

• Do 函数是启动整个 try - catch - finally 流程的关键方法。

  • 首先，它会检查 TryCatch 实例中的 try 函数是否已经被设置，如果没有设置，则直接返回，因为没有需要执行的代码逻辑。

  • 然后，使用 defer 关键字定义了一个延迟执行的匿名函数。这个匿名函数的作用是捕获在 try 函数执行过程中可能发生的 panic。当 try 函数执行出错并触发 panic 时，recover 函数会捕获到这个错误信息（err）。接着，检查 catch 函数是否已被设置，如果已设置，则将捕获到的错误信息转换为 error 类型（因为 recover 返回的是 interface{} 类型）并传递给 catch 函数进行处理。

  • 在 try 函数执行完毕后，如果没有发生错误，会检查返回的 err 是否为 nil。如果不为 nil，说明 try 函数执行过程中出现了错误，此时会手动触发 panic，以便让上面的 defer 函数捕获并处理这个错误。

  • 最后，无论 try 函数执行过程中是否发生错误，都会检查 finally 函数是否已被设置，如果已设置，则执行 finally 函数，完成最终的清理操作。

以下是一个使用 trycatch 包的示例：

func TestNew(t *testing.T) {
    // 创建一个 TryCatch 实例
    tc := New()
    // 设置 try 函数，这里故意制造一个空指针引用的错误
    tc.Try(func() error {
        var a *int
        *a += 1
        return nil
    }).Catch(func(err error) {
        // 捕获并打印错误信息
        t.Log(err)
    }).Finally(func() {
        // 执行最终操作并打印信息
        t.Log("Finally")
    }).Do()
}

在上述示例中：

• 首先调用 New 函数创建了一个 TryCatch 实例 tc。
• 然后通过链式调用 Try 方法设置了 try 函数，在这个函数中故意制造了一个空指针引用的错误（var a *int; *a += 1）。
• 接着链式调用 Catch 方法设置了 catch 函数，当 try 函数执行出错时，会在这个函数中捕获并打印错误信息。
• 再链式调用 Finally 方法设置了 finally 函数，无论 try 函数执行结果如何，都会执行这个函数并打印信息。
• 最后调用 Do 函数启动整个 try - catch - finally 流程，在这个流程中，try 函数执行出错，catch 函数捕获并处理错误，然后 finally 函数执行最终操作。

三、注意事项

• 在使用 TryCatch 结构体的 Do 函数时，如果 try 函数中发生的错误不是 error 类型（例如 panic 了一个非 error 类型的值），在 catch 函数中需要谨慎处理类型断言，否则可能导致程序崩溃。例如，如果 try 函数中执行了 panic("some non-error message")，在 catch 函数中进行 err.(error) 类型断言时就会出错。
• 虽然 trycatch 包提供了类似其他语言的错误处理结构，但在 Golang 中应根据具体场景合理使用，避免过度使用导致代码逻辑复杂度过高。因为 Golang 本身的错误处理机制（如返回错误值）在很多情况下已经足够有效和简洁，过度使用 trycatch 可能会使代码变得