Go语言高级特性：错误处理与反射

type error interface {
    Error() string
}

import "errors"

func Divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

import "fmt"

func OpenFile(filename string) error {
    if filename == "" {
        return fmt.Errorf("cannot open empty filename")
    }
    // ... 尝试打开文件 ...
    return nil
}

import (
    "errors"
    "fmt"
)

func OpenFile(filename string) error {
    if filename == "" {
        return fmt.Errorf("cannot open file: %w", errors.New("empty filename"))
    }
    // ... 尝试打开文件 ...
    return nil
}

type FileError struct {
    Filename string
    Code     int
    Message  string
}

func (e *FileError) Error() string {
    return fmt.Sprintf("file error (code %d): %s (filename: %s)", e.Code, e.Message, e.Filename)
}

func OpenFile(filename string) error {
    if filename == "" {
        return &FileError{
            Filename: filename,
            Code:     400,
            Message:  "empty filename",
        }
    }
    // ... 尝试打开文件 ...
    return nil
}

func ReadFile(filename string) ([]byte, error) {
    content, err := ioutil.ReadFile(filename)
    if err != nil {
        return nil, err  // 直接返回错误
    }
    return content, nil
}

func ProcessFile(filename string) {
    content, err := ReadFile(filename)
    if err != nil {
        // 处理错误
        fmt.Printf("Error reading file: %v\n", err)
        return
    }
    // 处理文件内容
    fmt.Printf("File content: %s\n", content)
}

content, _ := ReadFile(filename)  // 忽略错误

type APIError struct {
    StatusCode int
    Message    string
    RequestID  string
}

func (e *APIError) Error() string {
    return fmt.Sprintf("API error (status %d): %s (request ID: %s)", e.StatusCode, e.Message, e.RequestID)
}

type ValidationError struct {
    Field   string
    Value   interface{}
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("validation error for field '%s' (value: %v): %s", e.Field, e.Value, e.Message)
}

// 添加一个获取错误字段的方法
func (e *ValidationError) GetField() string {
    return e.Field
}

// 添加一个获取错误值的方法
func (e *ValidationError) GetValue() interface{} {
    return e.Value
}

func ValidateUser(user User) error {
    if user.Name == "" {
        return &ValidationError{
            Field:   "Name",
            Value:   user.Name,
            Message: "name cannot be empty",
        }
    }
    if user.Age < 0 || user.Age > 120 {
        return &ValidationError{
            Field:   "Age",
            Value:   user.Age,
            Message: "age must be between 0 and 120",
        }
    }
    return nil
}

func CreateUser(user User) {
    err := ValidateUser(user)
    if err != nil {
        if valErr, ok := err.(*ValidationError); ok {
            // 处理验证错误
            fmt.Printf("Validation failed for field '%s': %s\n", valErr.GetField(), valErr.Error())
        } else {
            // 处理其他错误
            fmt.Printf("Error: %v\n", err)
        }
        return
    }
    // 创建用户
    fmt.Printf("User created: %+v\n", user)
}

import "errors"

// 创建一个基础错误
baseErr := errors.New("base error")

// 创建一个包含基础错误的包装错误
wrappedErr := fmt.Errorf("wrapped error: %w", baseErr)

// 展开包装错误，获取基础错误
unwrappedErr := errors.Unwrap(wrappedErr)

import (
    "errors"
    "fmt"
)

func OpenFile(filename string) error {
    if filename == "" {
        return fmt.Errorf("cannot open file: %w", errors.New("empty filename"))
    }
    // ... 尝试打开文件 ...
    return nil
}

import (
    "errors"
    "fmt"
)

func main() {
    baseErr := errors.New("base error")
    wrappedErr1 := fmt.Errorf("first wrap: %w", baseErr)
    wrappedErr2 := fmt.Errorf("second wrap: %w", wrappedErr1)
    
    // 使用Is函数检查错误链中是否包含baseErr
    fmt.Println(errors.Is(wrappedErr2, baseErr))  // 输出：true
    
    // 定义一个自定义错误类型
    type MyError struct {
        message string
    }
    
    func (e *MyError) Error() string {
        return e.message
    }
    
    myErr := &MyError{message: "my error"}
    wrappedMyErr := fmt.Errorf("wrapped my error: %w", myErr)
    
    // 使用As函数尝试将错误链中的错误转换为MyError类型
    var targetErr *MyError
    if errors.As(wrappedMyErr, &targetErr) {
        fmt.Printf("Found MyError: %s\n", targetErr.Error())  // 输出：Found MyError: my error
    }
}

// 直接调用panic函数
panic("something went wrong")

// 除零错误会触发panic
result := 10 / 0

// 数组越界会触发panic
arr := [3]int{1, 2, 3}
fmt.Println(arr[10])

func SafeFunction() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("Recovered from panic: %v\n", r)
        }
    }()
    // ... 可能触发panic的代码 ...
    panic("something went wrong")
}

func ReadFile(filename string) ([]byte, error) {
    file, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer file.Close()  // 确保文件被关闭，即使发生错误
    
    content, err := ioutil.ReadAll(file)
    if err != nil {
        return nil, err
    }
    
    return content, nil
}

func ServeHTTP(w http.ResponseWriter, r *http.Request) {
    defer func() {
        if r := recover(); r != nil {
            // 记录panic信息
            log.Printf("Panic in ServeHTTP: %v\n%s\n", r, debug.Stack())
            // 向客户端返回500错误
            w.WriteHeader(http.StatusInternalServerError)
            w.Write([]byte("Internal Server Error"))
        }
    }()
    
    // ... 处理HTTP请求 ...
}

func DeferOrder() {
    defer fmt.Println("First defer")
    defer fmt.Println("Second defer")
    defer fmt.Println("Third defer")
    fmt.Println("Function body")
}

Function body
Third defer
Second defer
First defer

import "reflect"

func GetTypeInfo(x interface{}) {
    t := reflect.TypeOf(x)
    fmt.Printf("Type name: %s\n", t.Name())
    fmt.Printf("Type kind: %s\n", t.Kind())
}

import "reflect"

func GetValueInfo(x interface{}) {
    v := reflect.ValueOf(x)
    fmt.Printf("Value: %v\n", v.Interface())
    fmt.Printf("Value kind: %s\n", v.Kind())
}

import "reflect"

func GetKindInfo(x interface{}) {
    t := reflect.TypeOf(x)
    fmt.Printf("Type kind: %s\n", t.Kind())
    
    v := reflect.ValueOf(x)
    fmt.Printf("Value kind: %s\n", v.Kind())
}

import "reflect"

func FirstLaw() {
    x := 42
    t := reflect.TypeOf(x)  // 获取x的类型信息
    v := reflect.ValueOf(x) // 获取x的值信息
    
    fmt.Printf("Type: %s\n", t.Name())
    fmt.Printf("Value: %v\n", v.Interface())
}

import "reflect"

func SecondLaw() {
    x := 42
    v := reflect.ValueOf(x) // 获取x的值信息
    
    // 将反射对象转换回接口值
    i := v.Interface()
    
    // 使用类型断言获取具体类型的值
    y := i.(int)
    fmt.Printf("y: %d\n", y)
}

import "reflect"

func ThirdLaw() {
    x := 42
    
    // 传递x的指针，而不是x本身
    v := reflect.ValueOf(&x).Elem()
    
    // 检查值是否可以被设置
    if v.CanSet() {
        v.SetInt(100) // 修改x的值
    }
    
    fmt.Printf("x: %d\n", x) // 输出：x: 100
}

import "reflect"

func GetTypeName(x interface{}) string {
    t := reflect.TypeOf(x)
    return t.Name()
}

import "reflect"

func GetKindName(x interface{}) string {
    t := reflect.TypeOf(x)
    return t.Kind().String()
}

import "reflect"

type Writer interface {
    Write(p []byte) (n int, err error)
}

func ImplementsWriter(t reflect.Type) bool {
    writerType := reflect.TypeOf((*Writer)(nil)).Elem()
    return t.Implements(writerType)
}

import "reflect"

func GetValue(v reflect.Value) interface{} {
    return v.Interface()
}

import "reflect"

func GetBasicValue(v reflect.Value) interface{} {
    switch v.Kind() {
    case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
        return v.Int()
    case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
        return v.Uint()
    case reflect.Float32, reflect.Float64:
        return v.Float()
    case reflect.Bool:
        return v.Bool()
    case reflect.String:
        return v.String()
    default:
        return v.Interface()
    }
}

import "reflect"

func SetValue(x interface{}, newValue interface{}) error {
    v := reflect.ValueOf(x)
    
    // 检查x是否是指针
    if v.Kind() != reflect.Ptr {
        return fmt.Errorf("x must be a pointer")
    }
    
    // 获取指针指向的元素
    v = v.Elem()
    
    // 检查值是否可以被设置
    if !v.CanSet() {
        return fmt.Errorf("value cannot be set")
    }
    
    // 设置新值
    newV := reflect.ValueOf(newValue)
    if newV.Type().AssignableTo(v.Type()) {
        v.Set(newV)
        return nil
    }
    
    return fmt.Errorf("cannot assign %T to %T", newValue, v.Interface())
}

import "reflect"

func CallFunction(f interface{}, args ...interface{}) ([]interface{}, error) {
    v := reflect.ValueOf(f)
    
    // 检查f是否是函数
    if v.Kind() != reflect.Func {
        return nil, fmt.Errorf("f must be a function")
    }
    
    // 准备参数
    reflectArgs := make([]reflect.Value, len(args))
    for i, arg := range args {
        reflectArgs[i] = reflect.ValueOf(arg)
    }
    
    // 调用函数
    reflectResults := v.Call(reflectArgs)
    
    // 转换结果
    results := make([]interface{}, len(reflectResults))
    for i, result := range reflectResults {
        results[i] = result.Interface()
    }
    
    return results, nil
}

import "reflect"

type Person struct {
    Name string
    Age  int
}

func (p Person) Greet() string {
    return fmt.Sprintf("Hello, my name is %s.", p.Name)
}

func (p *Person) HaveBirthday() {
    p.Age++
}

func CallMethod(obj interface{}, methodName string, args ...interface{}) ([]interface{}, error) {
    v := reflect.ValueOf(obj)
    
    // 获取方法
    method := v.MethodByName(methodName)
    if !method.IsValid() {
        return nil, fmt.Errorf("method %s not found", methodName)
    }
    
    // 准备参数
    reflectArgs := make([]reflect.Value, len(args))
    for i, arg := range args {
        reflectArgs[i] = reflect.ValueOf(arg)
    }
    
    // 调用方法
    reflectResults := method.Call(reflectArgs)
    
    // 转换结果
    results := make([]interface{}, len(reflectResults))
    for i, result := range reflectResults {
        results[i] = result.Interface()
    }
    
    return results, nil
}

import "reflect"

type Person struct {
    Name string
    Age  int
    City string
}

func GetStructFields(obj interface{}) []reflect.StructField {
    t := reflect.TypeOf(obj)
    
    // 检查obj是否是结构体
    if t.Kind() != reflect.Struct {
        return nil
    }
    
    // 获取所有字段
    fields := make([]reflect.StructField, t.NumField())
    for i := 0; i < t.NumField(); i++ {
        fields[i] = t.Field(i)
    }
    
    return fields
}

import "reflect"

func GetStructFieldValue(obj interface{}, fieldName string) (interface{}, error) {
    v := reflect.ValueOf(obj)
    
    // 如果obj是指针，获取指针指向的元素
    if v.Kind() == reflect.Ptr {
        v = v.Elem()
    }
    
    // 检查v是否是结构体
    if v.Kind() != reflect.Struct {
        return nil, fmt.Errorf("obj must be a struct or a pointer to a struct")
    }
    
    // 获取字段
    field := v.FieldByName(fieldName)
    if !field.IsValid() {
        return nil, fmt.Errorf("field %s not found", fieldName)
    }
    
    return field.Interface(), nil
}

func SetStructFieldValue(obj interface{}, fieldName string, value interface{}) error {
    v := reflect.ValueOf(obj)
    
    // 检查obj是否是指针
    if v.Kind() != reflect.Ptr {
        return fmt.Errorf("obj must be a pointer to a struct")
    }
    
    // 获取指针指向的元素
    v = v.Elem()
    
    // 检查v是否是结构体
    if v.Kind() != reflect.Struct {
        return fmt.Errorf("obj must be a pointer to a struct")
    }
    
    // 获取字段
    field := v.FieldByName(fieldName)
    if !field.IsValid() {
        return fmt.Errorf("field %s not found", fieldName)
    }
    
    // 检查字段是否可以被设置
    if !field.CanSet() {
        return fmt.Errorf("field %s cannot be set", fieldName)
    }
    
    // 设置字段值
    valueV := reflect.ValueOf(value)
    if valueV.Type().AssignableTo(field.Type()) {
        field.Set(valueV)
        return nil
    }
    
    return fmt.Errorf("cannot assign %T to field %s of type %T", value, fieldName, field.Interface())
}

import "reflect"

type Person struct {
    Name string `json:"name" xml:"name"`
    Age  int    `json:"age" xml:"age"`
    City string `json:"city,omitempty" xml:"city"`
}

func GetStructFieldTags(obj interface{}) map[string]string {
    t := reflect.TypeOf(obj)
    tags := make(map[string]string)
    
    // 检查obj是否是结构体
    if t.Kind() != reflect.Struct {
        return tags
    }
    
    // 获取所有字段的标签
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        tag := field.Tag.Get("json")  // 获取json标签
        if tag != "" {
            tags[field.Name] = tag
        }
    }
    
    return tags
}

func CreateInstance(t reflect.Type) interface{} {
    // 创建一个指向结构体的指针
    instance := reflect.New(t)
    // 获取指针指向的元素
    elem := instance.Elem()
    // 设置结构体的字段
    for i := 0; i < t.NumField(); i++ {
        field := elem.Field(i)
        if field.CanSet() {
            // 根据字段类型设置默认值
            switch field.Kind() {
            case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
                field.SetInt(0)
            case reflect.String:
                field.SetString("")
            // ... 其他类型 ...
            }
        }
    }
    return instance.Interface()
}