【完全ガイド】初心者のためのGo言語のエラーハンドリング

この記事はで読むことができます。

こんにちは！今回は、Go言語（Golang）におけるエラーハンドリングについて、初心者の方にもわかりやすく解説していきます。エラーハンドリングは、安全で信頼性の高いプログラムを書く上で非常に重要な概念です。Go言語特有のエラーハンドリング手法を学び、実践的な例を通じてその使い方を理解していきましょう。

目次非表示

1. Go言語におけるエラーの基本概念
2. 基本的なエラーハンドリング
3. カスタムエラーの作成
4. エラーのラッピング（Go 1.13以降）
5. panic と recover
6. エラーハンドリングのベストプラクティス
まとめ

1. Go言語におけるエラーの基本概念

Go言語では、エラーは値として扱われます。これは、多くの言語で使用される例外処理とは異なるアプローチです。Go言語のエラーは error インターフェースとして定義されており、このインターフェースは以下のように定義されています。

type error interface {
    Error() string
}

このシンプルなインターフェースは、エラーメッセージを文字列として返す Error() メソッドのみを要求しています。

2. 基本的なエラーハンドリング

Go言語での最も基本的なエラーハンドリングパターンは、関数が値とエラーを返し、呼び出し側でそのエラーをチェックするというものです。

package main

import (
    "fmt"
    "errors"
)

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

func main() {
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Result:", result)

    result, err = divide(10, 0)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Result:", result)
}

この例では、divide 関数が結果と共にエラーを返しています。エラーが nil でない場合、エラーが発生したことを意味します。

result

Result: 5
Error: division by zero

3. カスタムエラーの作成

Go言語では、errors.New() 関数を使って簡単にカスタムエラーを作成できます。また、より複雑なエラーを作成するには、error インターフェースを実装した独自の型を定義することもできます。

package main

import (
    "fmt"
    "errors"
)

// カスタムエラー型の定義
type MyError struct {
    Code    int
    Message string
}

// error インターフェースの実装
func (e *MyError) Error() string {
    return fmt.Sprintf("Error %d: %s", e.Code, e.Message)
}

func doSomething(flag bool) error {
    if flag {
        return errors.New("simple error")
    }
    return &MyError{Code: 500, Message: "Something went wrong"}
}

func main() {
    err := doSomething(true)
    if err != nil {
        fmt.Println(err)
    }

    err = doSomething(false)
    if err != nil {
        fmt.Println(err)
        if myErr, ok := err.(*MyError); ok {
            fmt.Printf("Error code: %d\n", myErr.Code)
        }
    }
}

この例では、簡単なエラーと、より詳細な情報を含むカスタムエラー型を使用しています。

result

simple error
Error 500: Something went wrong
Error code: 500

4. エラーのラッピング（Go 1.13以降）

Go 1.13から、エラーをラップする機能が追加されました。これにより、エラーに追加のコンテキスト情報を付加しつつ、元のエラーを保持することができます。

package main

import (
    "fmt"
    "errors"
)

func innerFunction() error {
    return errors.New("inner error")
}

func middleFunction() error {
    err := innerFunction()
    if err != nil {
        return fmt.Errorf("middle function error: %w", err)
    }
    return nil
}

func outerFunction() error {
    err := middleFunction()
    if err != nil {
        return fmt.Errorf("outer function error: %w", err)
    }
    return nil
}

func main() {
    err := outerFunction()
    if err != nil {
        fmt.Println(err)

        // エラーのアンラッピング
        if innerErr := errors.Unwrap(err); innerErr != nil {
            fmt.Println("Unwrapped error:", innerErr)
        }

        // エラーチェーン内の特定のエラーを検索
        if errors.Is(err, errors.New("inner error")) {
            fmt.Println("Inner error detected")
        }
    }
}

この例では、エラーをラップしてコンテキスト情報を追加し、errors.Unwrap() と errors.Is() を使用してエラーチェーンを操作しています。

result

outer function error: middle function error: inner error
Unwrapped error: middle function error: inner error
Inner error detected

5. panic と recover

Go言語には、致命的なエラーに対処するための panic と recover というメカニズムがあります。ただし、これらは通常のエラーハンドリングには使用せず、本当に回復不可能な状況でのみ使用するべきです。

HTML

package main

import "fmt"

func mayPanic() {
    panic("a problem")
}

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered. Error:\n", r)
        }
    }()
    mayPanic()
    fmt.Println("After mayPanic()") // この行は実行されない
}

この例では、mayPanic() 関数が panic を引き起こしますが、main 関数内の defer された無名関数が recover を使用してパニックから回復します。

result

Recovered. Error:
 a problem

6. エラーハンドリングのベストプラクティス

エラーを無視しない：返されたエラーは常にチェックしましょう。
エラーをラップする：エラーにコンテキスト情報を追加することで、デバッグが容易になります。
エラーメッセージは明確に：エラーメッセージは具体的で、何が問題かを明確に示すものにしましょう。
ログを活用する：エラーが発生した場合、適切にログを記録しましょう。
panic の使用は最小限に：panic は本当に回復不可能な状況でのみ使用しましょう。
エラー型を適切に定義する：必要に応じて、カスタムエラー型を定義し、より詳細な情報を含めましょう。

package main

import (
    "fmt"
    "log"
)

type ConfigError struct {
    ConfigFile string
    Message    string
}

func (e *ConfigError) Error() string {
    return fmt.Sprintf("Configuration error in %s: %s", e.ConfigFile, e.Message)
}

func readConfig(filename string) error {
    // 設定ファイルの読み込みをシミュレート
    if filename == "config.json" {
        return nil
    }
    return &ConfigError{
        ConfigFile: filename,
        Message:    "file not found",
    }
}

func setupApplication() error {
    err := readConfig("settings.json")
    if err != nil {
        return fmt.Errorf("setup failed: %w", err)
    }
    return nil
}

func main() {
    err := setupApplication()
    if err != nil {
        log.Printf("Application startup failed: %v", err)
        if configErr, ok := err.(*ConfigError); ok {
            fmt.Printf("Configuration error occurred. Please check the file: %s\n", configErr.ConfigFile)
        }
        return
    }
    fmt.Println("Application started successfully")
}

この例では、カスタムエラー型の使用、エラーのラッピング、適切なエラーメッセージの作成、そしてエラーの種類に基づいた処理を示しています。

result

2023/04/10 12:34:56 Application startup failed: setup failed: Configuration error in settings.json: file not found
Configuration error occurred. Please check the file: settings.json