Go言語のerror型とエラーハンドリングの慣習！初心者向けガイド

type error interface {
    Error() string
}

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

result, err := divide(10, 0)
if err != nil {
    fmt.Println("エラーが発生しました:", err)
    return
}
fmt.Println("結果:", result)

package main

import (
    "errors"
    "fmt"
)

func validateAge(age int) error {
    if age < 0 {
        return errors.New("年齢は0以上である必要があります")
    }
    if age > 150 {
        return errors.New("年齢が無効です")
    }
    return nil
}

func main() {
    err := validateAge(-5)
    if err != nil {
        fmt.Println("エラー:", err)
    }
}

package main

import (
    "fmt"
)

func checkBalance(balance, amount float64) error {
    if amount > balance {
        return fmt.Errorf("残高不足: 残高 %.2f円に対して %.2f円の出金は不可能です", 
                          balance, amount)
    }
    return nil
}

func main() {
    err := checkBalance(1000, 1500)
    if err != nil {
        fmt.Println("エラー:", err)
    }
}

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

func (e ValidationError) Error() string {
    return fmt.Sprintf("フィールド '%s' の値 '%v' は無効です: %s", 
                       e.Field, e.Value, e.Message)
}

func validateUser(name string, age int) error {
    if name == "" {
        return ValidationError{
            Field:   "name",
            Value:   name,
            Message: "名前は必須です",
        }
    }
    if age < 0 {
        return ValidationError{
            Field:   "age", 
            Value:   age,
            Message: "年齢は0以上である必要があります",
        }
    }
    return nil
}

func processUser(userID string) error {
    // ユーザー情報の取得
    user, err := getUserFromDB(userID)
    if err != nil {
        return err  // エラーが発生したらすぐに返す
    }
    
    // バリデーション
    err = validateUser(user)
    if err != nil {
        return err  // エラーが発生したらすぐに返す
    }
    
    // 処理の実行
    err = saveUser(user)
    if err != nil {
        return err  // エラーが発生したらすぐに返す
    }
    
    return nil  // 成功
}

package main

import (
    "errors"
    "fmt"
)

func getUserFromDB(userID string) (string, error) {
    // データベースエラーをシミュレート
    return "", errors.New("connection timeout")
}

func processUser(userID string) error {
    user, err := getUserFromDB(userID)
    if err != nil {
        // 元のエラーをラップして、より詳細な情報を追加
        return fmt.Errorf("ユーザー情報の取得に失敗しました (userID: %s): %w", 
                         userID, err)
    }
    
    fmt.Println("ユーザー:", user)
    return nil
}

func main() {
    err := processUser("user123")
    if err != nil {
        fmt.Println("エラー:", err)
        
        // 元のエラーを取得
        var originalErr error
        if errors.Unwrap(err) != nil {
            originalErr = errors.Unwrap(err)
            fmt.Println("元のエラー:", originalErr)
        }
    }
}

func safeDivide(a, b float64) (result float64, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("予期しないエラーが発生しました: %v", r)
        }
    }()
    
    if b == 0 {
        return 0, errors.New("ゼロ除算エラー")  // 通常のエラー処理
    }
    
    return a / b, nil
}

// 良い例
errors.New("user not found")
errors.New("invalid email format")
fmt.Errorf("failed to connect to database: %w", err)

// 避けるべき例
errors.New("User not found.")        // 大文字開始、ピリオド付き
errors.New("Something went wrong")   // 曖昧すぎる

package user

import "errors"

// センチネルエラーの定義
var (
    ErrUserNotFound = errors.New("user not found")
    ErrInvalidEmail = errors.New("invalid email format")
    ErrDuplicateUser = errors.New("user already exists")
)

func GetUser(id string) (*User, error) {
    // 処理...
    if userNotExists {
        return nil, ErrUserNotFound
    }
    // 処理...
}

// 呼び出し側でのエラー判定
func main() {
    user, err := GetUser("123")
    if err != nil {
        if errors.Is(err, user.ErrUserNotFound) {
            fmt.Println("ユーザーが見つかりませんでした")
            return
        }
        fmt.Println("その他のエラー:", err)
        return
    }
    fmt.Println("ユーザー:", user)
}

// エラーを意図的に無視する場合
_, _ = fmt.Fprintf(w, "output")  // アンダースコアで明示的に無視

// または、コメントで説明
result, err := someFunction()
// この操作は失敗しても問題ないため、エラーを無視
_ = err

type APIError struct {
    StatusCode int
    Message    string
    Details    map[string]interface{}
}

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

func callAPI(endpoint string) error {
    // API呼び出し処理...
    if responseCode != 200 {
        return APIError{
            StatusCode: responseCode,
            Message:    "API call failed",
            Details: map[string]interface{}{
                "endpoint": endpoint,
                "timestamp": time.Now(),
            },
        }
    }
    return nil
}