package main

import (
    "errors"
    "fmt"
)

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

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("Result: %d\n", result)
}

type error interface {
    Error() string
}

package main

import (
    "fmt"
)

// 自定義錯(cuò)誤類型
type DivideError struct {
    Dividend int
    Divisor  int
}

// 實(shí)現(xiàn)Error方法
func (e *DivideError) Error() string {
    return fmt.Sprintf("division error: cannot divide %d by %d", e.Dividend, e.Divisor)
}

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, &DivideError{Dividend: a, Divisor: b}
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        if de, ok := err.(*DivideError); ok {
            fmt.Printf("Divide error: dividend=%d, divisor=%d\n", de.Dividend, de.Divisor)
        } else {
            fmt.Printf("Error: %v\n", err)
        }
        return
    }
    fmt.Printf("Result: %d\n", result)
}

package main

import (
    "errors"
    "fmt"
)

var ErrDivideByZero = errors.New("division by zero")

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, ErrDivideByZero
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        if errors.Is(err, ErrDivideByZero) {
            fmt.Println("Divide by zero error")
        } else {
            fmt.Printf("Error: %v\n", err)
        }
        return
    }
    fmt.Printf("Result: %d\n", result)
}

go get -u github.com/pkg/errors

package main

import (
    "fmt"
    "github.com/pkg/errors"
)

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

func process(a, b int) (int, error) {
    result, err := divide(a, b)
    if err != nil {
        return 0, errors.Wrap(err, "process failed")
    }
    return result, nil
}

func main() {
    result, err := process(10, 0)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        fmt.Printf("Stack trace:\n%+v\n", err)
        return
    }
    fmt.Printf("Result: %d\n", result)
}

package main

import (
    "fmt"
    "github.com/pkg/errors"
)

// 自定義錯(cuò)誤類型
type AppError struct {
    Code    int
    Message string
}

func (e *AppError) Error() string {
    return fmt.Sprintf("app error: code=%d, message=%s", e.Code, e.Message)
}

// 模擬數(shù)據(jù)庫(kù)錯(cuò)誤
func queryDatabase(id int) (string, error) {
    if id <= 0 {
        return "", errors.New("invalid id")
    }
    return "data", nil
}

// 模擬業(yè)務(wù)邏輯
func processData(id int) (string, error) {
    data, err := queryDatabase(id)
    if err != nil {
        return "", errors.Wrap(err, "failed to query database")
    }
    return data, nil
}

// 模擬API處理
func handleRequest(id int) (string, error) {
    data, err := processData(id)
    if err != nil {
        return "", errors.Wrap(err, "failed to process data")
    }
    return data, nil
}

func main() {
    // 測(cè)試錯(cuò)誤處理
    data, err := handleRequest(-1)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        fmt.Printf("Stack trace:\n%+v\n", err)
        
        // 檢查錯(cuò)誤類型
        var appErr *AppError
        if errors.As(err, &appErr) {
            fmt.Printf("App error code: %d\n", appErr.Code)
        }
        return
    }
    fmt.Printf("Data: %s\n", data)
}

package main

import (
    "fmt"
    "net/http"
    "github.com/pkg/errors"
)

// 錯(cuò)誤處理中間件
func errorMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                fmt.Printf("Panic: %v\n", err)
                w.WriteHeader(http.StatusInternalServerError)
                fmt.Fprint(w, "Internal Server Error")
            }
        }()
        next.ServeHTTP(w, r)
    })
}

// 處理函數(shù)
func handleDivide(w http.ResponseWriter, r *http.Request) {
    // 模擬錯(cuò)誤
    err := errors.New("division by zero")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        w.WriteHeader(http.StatusBadRequest)
        fmt.Fprint(w, "Bad Request: "+err.Error())
        return
    }
    fmt.Fprint(w, "Success")
}

func main() {
    http.Handle("/divide", errorMiddleware(http.HandlerFunc(handleDivide)))
    fmt.Println("Server starting on :8080")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        fmt.Printf("Server failed: %v\n", err)
    }
}