Go言語の標準ライブラリを使ったエラー処理のまとめ

package main

import (
	"errors"
	"fmt"
)

// divideはaをbで割った商と余りを返す
func divide(a, b int) (int, error) {
	if b == 0 {
		// エラーが発生した場合、nilではないerror値を返す
		return 0, errors.New("Division by zero: ゼロで割ることはできません")
	}
	// 成功した場合、結果とnilを返す
	return a / b, nil
}

func main() {
	//　エラーが発生しないケース
	fmt.Print("Case 1: ")
	result, err := divide(10, 2)
	if err != nil {
		// エラーが発生した場合はここに到達する
		fmt.Println("エラー:", err)
		return
	}

	fmt.Print("OK.")
	fmt.Println("結果:", result) // 結果: 5

	fmt.Println("-------------------------")
	fmt.Print("Case 2: ")

	// エラーが発生するケース
	result, err = divide(10, 0)
	if err != nil {
		// エラーが発生した場合はここに到達する
		fmt.Println("エラー:", err) // エラー: ゼロで割ることはできません
		return
	}
	fmt.Println("結果:", result)
}

package main

import (
	"errors"
	"fmt"
)

// ErrNotFoundを定義
var ErrNotFound = errors.New("Item not found")

// findItem はスライスからアイテムを探します。
func findItem(items []string, target string) (string, error) {
	for _, item := range items {
		if item == target {
			return item, nil
		}
	}
	// 見つからない場合は ErrNotFound を返す
	return "", ErrNotFound
}

func main() {
	data := []string{"apple", "banana", "cherry"}

	// 成功するケース
	item, err := findItem(data, "banana")
	if err != nil {
		fmt.Println("エラー:", err)
		return
	}
	fmt.Println("見つかったアイテム:", item) // 見つかったアイテム: banana

	fmt.Println("---------------------------------")

	// 失敗するケース (アイテムが見つからない)
	item, err = findItem(data, "grape")
	if err != nil {
		// errors.Is を使って、返されたエラーが ErrNotFound であるかを確認
		if errors.Is(err, ErrNotFound) {
			fmt.Println("エラー: アイテムが見つかりませんでした。", "err =", err)
		} else {
			fmt.Println("その他のエラー:", err)
		}
		return
	}
	fmt.Println("見つかったアイテム:", item)
}

package main

import "fmt"

var users []string

// addUserはユーザーをusersに追加する
func AddUser(username string) error {
	if len(username) < 5 {
		// 動的な情報 (username) を含むエラーメッセージを作成
		return fmt.Errorf("ユーザー名 '%s' は短すぎます。5文字以上必要です。", username)
	}
	fmt.Printf("ユーザー '%s' を追加しました。\n", username)
	users = append(users, username)
	return nil
}

func main() {
	// 成功するケース
	err := AddUser("hogehoge")
	if err != nil {
		fmt.Println("エラー:", err)
	}

	fmt.Println("--------------------")

	// 失敗するケース (ユーザー名が短い)
	err = AddUser("hoge")
	if err != nil {
		fmt.Println("エラー:", err) // エラー: ユーザー名 'go' は短すぎます。5文字以上必要です。
	}

	// usersを表示
	fmt.Println("--------------------")
	fmt.Println("ユーザー:", users)
}

package main

import (
	"errors"
	"fmt"
)

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

	return a / b, nil
}

func average(datas []int) (int, error) {
	sum := 0
	for _, e := range datas {
		sum += e
	}

	ave, err := div(sum, len(datas))
	if err != nil {
		return 0, fmt.Errorf("平均を計算中にエラーが発生しました: %w", err)
	}

	return ave, nil
}

func main() {
	ave, err := average([]int{1, 2, 3, 4, 5})
	if err != nil {
		// ラップされたエラーは、%v で出力するとチェイン全体が表示される
		fmt.Printf("最終的なエラー: %v\n", err)
		return
	}
	fmt.Println("平均 : ", ave)

	fmt.Println("------------------")
	ave, err = average([]int{})
	if err != nil {
		// ラップされたエラーは、%v で出力するとチェイン全体が表示される
		fmt.Printf("最終的なエラー: %v\n", err)
		return
	}
	fmt.Println("平均 : ", ave)

}

package main

import (
	"errors"
	"fmt"
)

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

	return a / b, nil
}

func average(datas []int) (int, error) {
	sum := 0
	for _, e := range datas {
		sum += e
	}

	ave, err := div(sum, len(datas))
	if err != nil {
		return 0, fmt.Errorf("平均を計算中にエラーが発生しました: %w", err)
	}

	return ave, nil
}

func main() {
	ave, err := average([]int{1, 2, 3, 4, 5})
	if err != nil {
		for e := err; e != nil; e = errors.Unwrap(e) {
			fmt.Printf("  - %v\n", e)
		}
		return
	}
	fmt.Println("平均 : ", ave)

	fmt.Println("------------------")
	ave, err = average([]int{})
	if err != nil {
		for e := err; e != nil; e = errors.Unwrap(e) {
			fmt.Printf("  - %v\n", e)
		}
		return
	}
	fmt.Println("平均 : ", ave)

}

package main

import (
	"errors"
	"fmt"
)

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

func div(a, b int) (int, error) {
	if b == 0 {
		return 0, ErrDivideByZero
	}

	return a / b, nil
}

func average(datas []int) (int, error) {
	sum := 0
	for _, e := range datas {
		sum += e
	}

	ave, err := div(sum, len(datas))
	if err != nil {
		return 0, fmt.Errorf("平均を計算中にエラーが発生しました: %w", err)
	}

	return ave, nil
}

func main() {
	ave, err := average([]int{})
	if err != nil {
		if errors.Is(err, ErrDivideByZero) {
			fmt.Println("要素数がゼロです")
		} else {
			fmt.Println("不明なエラー:", err)
		}
		return
	}
	fmt.Println("平均 : ", ave)

}

package main

import (
	"errors"
	"fmt"
)

// カスタムエラー型
type DivideByZeroError struct {
	a, b int
}

func (e *DivideByZeroError) Error() string {
	return fmt.Sprintf("cannot divide a = %d by b = %d", e.a, e.b)
}

func div(a, b int) (int, error) {
	if b == 0 {
		return 0, &DivideByZeroError{a, b}
	}
	return a / b, nil
}

func average(datas []int) (int, error) {
	sum := 0
	for _, e := range datas {
		sum += e
	}

	ave, err := div(sum, len(datas))
	if err != nil {
		return 0, fmt.Errorf("平均を計算中にエラーが発生しました: %w", err)
	}

	return ave, nil
}

func main() {
	ave, err := average([]int{})
	if err != nil {
		var divideErr *DivideByZeroError
		if errors.As(err, ÷Err) {
			fmt.Println("要素数がゼロです", divideErr)
		} else {
			fmt.Println("不明なエラー:", err)
		}
		return
	}
	fmt.Println("平均 : ", ave)
}

package main

import (
	"fmt"

	cerrors "github.com/cockroachdb/errors"
)

func div(a, b int) (int, error) {
	if b == 0 {
		// スタックトレース付きエラーを生成
		return 0, cerrors.New("divide by zero")
	}

	return a / b, nil
}

func average(datas []int) (int, error) {
	sum := 0
	for _, e := range datas {
		sum += e
	}

	ave, err := div(sum, len(datas))
	if err != nil {
		// スタックトレースを保持したままラップ
		return 0, cerrors.Wrap(err, "平均を計算中にエラーが発生しました")
	}

	return ave, nil
}

func main() {
	ave, err := average([]int{}) // 要素数ゼロ → div(sum, 0) → divide by zero
	if err != nil {
		fmt.Printf("最終的なエラー:\n%+v\n", err)
		return
	}
	fmt.Println("平均 : ", ave)
}