Go语言错误处理：获取、传递与安全类型断言实践指南

package main

import (
    "errors"
    "fmt"
)

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("除数不能为零") // 创建并返回一个错误
    }
    return a / b, nil // 没有错误时返回nil
}

func main() {
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("发生错误:", err) // 打印错误信息
    } else {
        fmt.Println("结果:", result)
    }

    result, err = divide(10, 0)
    if err != nil {
        fmt.Println("发生错误:", err)
    } else {
        fmt.Println("结果:", result)
    }
}

结果: 5
发生错误: 除数不能为零

type error interface {
    Error() string
}

package main

import (
    "fmt"
)

func validateAge(age int) error {
    if age < 0 {
        return fmt.Errorf("年龄不能为负数，当前输入为: %d", age)
    }
    if age > 150 {
        return fmt.Errorf("年龄不能超过150岁，当前输入为: %d", age)
    }
    return nil
}

func main() {
    err := validateAge(-5)
    if err != nil {
        fmt.Println(err)
    }

    err = validateAge(200)
    if err != nil {
        fmt.Println(err)
    }

    err = validateAge(30)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println("年龄有效。")
    }
}

package main

import "fmt"

func riskyOperation() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("捕获到 panic:", r)
            // 在这里可以进行一些清理或日志记录
        }
    }()
    fmt.Println("开始执行 riskyOperation")
    panic("这是一个故意触发的 panic！") // 触发 panic
    fmt.Println("riskyOperation 结束 (不会执行到这里)")
}

func main() {
    fmt.Println("主函数开始")
    riskyOperation()
    fmt.Println("主函数结束") // 即使 riskyOperation 发生 panic，主函数也能继续执行
}

主函数开始
开始执行 riskyOperation
捕获到 panic: 这是一个故意触发的 panic！
主函数结束

package main

import "fmt"

func main() {
    var i interface{} = "hello"
    // var i interface{} = 123 // 如果是数字，下面的断言就会 panic

    s := i.(float64) // 尝试将字符串断言为 float64，会 panic
    fmt.Println(s)
}

value, ok := someInterface.(SomeType)
if ok {
    // 断言成功，可以使用 value
} else {
    // 断言失败，处理错误
}

package main

import (
    "errors"
    "fmt"
)

// assertFloat64 尝试将一个 interface{} 类型的值断言为 float64。
// 如果断言成功，返回 nil 错误；如果失败，则返回一个自定义错误。
func assertFloat64(n interface{}) error {
    // 使用“逗号，ok”惯用法进行类型断言。
    // f 将是断言后的 float64 值，如果成功。
    // ok 是一个布尔值，表示断言是否成功。
    f, ok := n.(float64)

    // 如果 ok 为 true，表示断言成功。
    if ok {
        fmt.Printf("成功断言: %v 是 float64 类型，值为 %f\n", n, f)
        return nil // 没有错误，返回 nil
    }

    // 如果 ok 为 false，表示断言失败。
    // 构造并返回一个描述断言失败的自定义错误。
    return errors.New(fmt.Sprintf("无法断言 \"%v\" 是 float64 类型。\n", n))
}

func main() {
    // 示例 1: 成功断言
    // 1024.0 是一个 float64 类型
    err := assertFloat64(1024.0)
    if err != nil {
        fmt.Println("错误:", err)
    }

    fmt.Println("---")

    // 示例 2: 断言失败
    // "foo" 不是 float64 类型
    err = assertFloat64("foo")
    if err != nil {
        fmt.Println("错误:", err)
    }

    fmt.Println("---")

    // 示例 3: 断言失败，nil 值
    // nil 也不是 float64 类型
    var nilVal interface{}
    err = assertFloat64(nilVal)
    if err != nil {
        fmt.Println("错误:", err)
    }
}

成功断言: 1024 是 float64 类型，值为 1024.000000
---
错误: 无法断言 "foo" 是 float64 类型。
---
错误: 无法断言 "<nil>" 是 float64 类型。