ホーム / Go言語 /

Go言語エラーハンドリングを徹底解説！基礎から実践まで

2025年4月17日木曜日

Go言語

この記事では、Go言語のエラーハンドリングについて、初めての人でもつまづかないように、ひとつひとつやさしく解説します。

読み進めるごとに「ああ、そういうことか！」と、目からウロコが落ちるはず。途中で出てくるサンプルコードも、誰でもすぐ真似できるものばかり。

この記事で学べること

  • Go言語のエラーハンドリングの基本的な考え方
  • `error`インターフェースって何？ どういう仕組み？
  • お決まりの`if err != nil`パターンの書き方とその意味
  • ファイル操作や型変換での具体的なエラー処理の例
  • 自分でオリジナルのエラーを作る方法（`errors.New`, `fmt.Errorf`）
  • エラー処理を書くときに気をつけたいポイント

Go言語のエラーハンドリングとは？基本を理解しよう

まず、Go言語がどうして他の言語、例えばJavaやPythonなんかでよく見る `try-catch` みたいな仕組みを使わないのか、その理由からお話ししましょう。

Go言語の設計思想の根っこには、「エラーは例外的なものではなく、プログラムの正常な動作の一部として起こりうるものだ」という考え方があります。ファイルが見つからないとか、ネットワーク接続が切れるとか、そういうのはプログラムを書いていれば普通に遭遇することですよね？

だからGoでは、エラーを特別な構文で捕捉するんじゃなくて、関数の戻り値の一つ、つまり「エラーもただの値（value）である」として扱います。関数が処理結果と一緒に、「処理中にこんなエラーが出たよ」という情報を返せるようにしているわけです。

その「エラー情報」を表すために使われるのが、Goの組み込み型である `error` インターフェースです。インターフェースって聞くと難しく感じるかもしれませんが、ここでは「エラーを表すための統一ルール」くらいの感じで捉えておけばOKです。

ちゃんとエラーハンドリングを書くことで、プログラムが予期せぬエラーで突然止まってしまうのを防いだり、どこで問題が起きたのか突き止めやすくしたりできます。つまり、より丈夫で信頼できるプログラムを作るための、とっても大事な作法なんですね。

Go言語のエラーハンドリングの基本的な書き方：`if err != nil`

Go言語のエラーハンドリングで、もうこれでもか！というくらい頻繁に目にするのが、 `if err != nil` という書き方です。これがGoの流儀であり、エラー処理の基本中の基本になります。

Goの関数は、複数の値を返すことができます（多値返却といいます）。エラーが発生する可能性のある関数の多くは、慣習として、最後の戻り値に `error` 型の値を返すように作られています。

例えば、何か処理を行う `doSomething()` という関数があったとして、それが処理結果のデータと、エラー情報の両方を返す場合、こんな風に受け取ります。

result, err := doSomething()

ここで、`err` にエラー情報が入っているかどうかをチェックするのが、お決まりの `if` 文です。

result, err := doSomething()
if err != nil {
    // エラーが発生した場合の処理をここに書く
    // (例: エラーメッセージを表示する、処理を中断してエラーを呼び出し元に返す など)
    fmt.Println("エラーが発生しました:", err)
    return // または return err など
}

// エラーがなかった場合（err が nil だった場合）の処理を続ける
fmt.Println("処理成功！結果:", result)

この `if err != nil` のブロックが、エラーハンドリングの核となる部分です。関数を呼び出すたびにこのチェックを書くのは、最初はちょっと面倒に感じるかもしれません。

でも、「エラーが発生するかもしれない箇所では、必ずチェックする」という意識を持つことが、Goプログラミングではとても大事なんです。この一手間が、後々のバグを防ぎ、コードの安全性を高めてくれます。

`error`インターフェースを理解する

さて、先ほどから登場している `error` 型ですが、これはGoの組み込みインターフェースです。インターフェースというのは、特定のメソッドを持っている型ですよ、という「契約」のようなものです。

`error` インターフェースの契約内容はとってもシンプルで、`Error() string` というメソッドを一つだけ持っていること、ただそれだけです。

type error interface {
    Error() string
}

この `Error()` メソッドは、そのエラーの内容を表す文字列（エラーメッセージ）を返す役割を持っています。

このシンプルな共通ルールがあるおかげで、Goでは様々な種類のエラー（標準ライブラリが返すエラー、自分で作ったカスタムエラーなど）を、すべて同じ `error` 型として扱うことができます。

そして、どんな `error` 型の値からでも、`.Error()` を呼び出せばエラーメッセージを取得できる、というわけです。

// 何らかの関数を呼び出してエラーを受け取る
_, err := os.Open("存在しないファイル.txt") 
if err != nil {
    // err は error インターフェースを満たす値
    // .Error() でエラーメッセージを取得できる
    fmt.Println("エラーメッセージ:", err.Error()) 
}

このように、エラーの詳細を知りたいときは `err.Error()` を使う、と覚えておきましょう。

定番パターン `if err != nil` を使いこなす

それでは、`if err != nil` パターンをもう少し具体的に見ていきましょう。このパターンの良いところは、エラーが発生したら、その場ですぐに対応できる点です。

よくある対応は、エラーが発生したことをログに出力したり、関数の処理をそこで中断して、受け取ったエラーをそのまま呼び出し元の関数に返す（エラーを上に伝播させる）ことです。

package main

import (
    "fmt"
    "strconv"
)

// 文字列を数値に変換して返す関数 (エラーも返す可能性がある)
func convertToInt(s string) (int, error) {
    num, err := strconv.Atoi(s) // 文字列を数値に変換
    if err != nil {
        // エラーが発生したら、ここで処理を中断し、
        // 呼び出し元にエラー情報を伝える
        fmt.Println("変換エラー発生！:", err)
        return 0, err // ゼロ値とエラーを返す
    }
    // エラーがなければ、変換後の数値と nil (エラーなし) を返す
    return num, nil
}

func main() {
    num1, err1 := convertToInt("123")
    if err1 != nil {
        // convertToInt からエラーが返ってきた場合の処理
        fmt.Println("main でエラーを受け取りました:", err1)
    } else {
        fmt.Println("変換成功:", num1)
    }

    fmt.Println("---")

    num2, err2 := convertToInt("abc") // わざとエラーを起こす
    if err2 != nil {
        // convertToInt からエラーが返ってきた場合の処理
        fmt.Println("main でエラーを受け取りました:", err2)
    } else {
        fmt.Println("変換成功:", num2)
    }
}

このコードを実行すると、`convertToInt("abc")` の呼び出しでエラーが発生し、`convertToInt` 関数内でエラーメッセージが出力され、さらに `main` 関数にもエラーが伝わってきているのが分かります。

このように `if err != nil` を使ってエラーチェックを行い、エラーがあったら即座に `return` する（これは「早期リターン」と呼ばれます）ことで、正常系の処理とエラー系の処理の流れが明確に分かれ、コードがとても読みやすくなります。

実践！Go言語エラーハンドリングの使い方

理屈は分かってきたけど、実際のプログラムでどう書けばいいの？と思いますよね。ここからは、よくある具体的な場面を取り上げて、エラーハンドリングのサンプルコードを見ていきましょう！

ファイル操作や、ユーザー入力の処理などでよく登場する、文字列と数値の変換といった場面でのエラー処理を扱います。ぜひ、お手元の環境で実際にコードを動かして試してみてくださいね。

サンプル1：ファイルを開く時のエラー処理

プログラムでファイルを読み書きすることはよくあります。ファイルを開く際には、`os.Open()` という関数を使いますが、指定したファイルが存在しなかったり、読み取り権限がなかったりするとエラーが発生します。

package main

import (
	"fmt"
	"os"
)

func main() {
	// 存在しないであろうファイル名を指定
	fileName := "存在しないはずのファイル.txt"

	// ファイルを開く試み
	file, err := os.Open(fileName)
	// ★ここでエラーチェック！
	if err != nil {
		fmt.Printf("ファイル '%s' を開けませんでした。\n", fileName)
		fmt.Println("エラー詳細:", err) 
		// エラーが発生したので、これ以上処理を進めずに終了
		return 
	}

	// 【重要】defer を使って、関数終了時に必ずファイルを閉じるようにする
	// ただし、↑のエラーチェックの後で行うこと！
	// (エラー発生時は file が nil のままなので、nil に対して Close() を呼ぶとパニックする)
	defer file.Close() 

	// ここまで来たら、ファイルは正常に開けている
	fmt.Printf("ファイル '%s' を正常に開けました。\n", fileName)

	// ... 本来ならここでファイルの内容を読み書きする処理 ...
	fmt.Println("ファイル操作を実行します...") 
}

実行結果（ファイルが存在しない場合）

ファイル '存在しないはずのファイル.txt' を開けませんでした。
エラー詳細: open 存在しないはずのファイル.txt: no such file or directory

もし、存在するファイル名を指定すれば、エラーは発生せず（`err` が `nil` になり）、`if` ブロックはスキップされ、「正常に開けました」というメッセージが表示されるはずです。

ポイントは、`os.Open()` の直後に `if err != nil` でしっかりエラーチェックを行うことです。また、`defer file.Close()` は、ファイルが正常に開けた後（エラーチェックの後）に書くようにしましょう。

サンプル2：文字列を数値に変換する時のエラー処理

ウェブアプリケーションなどでユーザーが入力した文字列を数値として扱いたい、といった場面はよくあります。

文字列を整数に変換するには `strconv.Atoi()` （Atoiは "ASCII to Integer" の略）を使いますが、もし文字列が数字でなかった場合はエラーになります。

package main

import (
	"fmt"
	"strconv"
)

func main() {
	inputs := []string{"123", "456円", "789"} // 変換する文字列のリスト

	for _, input := range inputs {
		fmt.Printf("入力: '%s'\n", input)
		num, err := strconv.Atoi(input) 
		// ★ここでエラーチェック！
		if err != nil {
			// 変換に失敗した場合
			fmt.Println("-> エラー: 数値に変換できませんでした。")
			fmt.Println("   エラー詳細:", err) 
		} else {
			// 変換に成功した場合
			fmt.Println("-> 成功: 変換後の数値:", num)
		}
		fmt.Println("---")
	}
}

実行結果

入力: '123'
-> 成功: 変換後の数値: 123
---
入力: '456円'
-> エラー: 数値に変換できませんでした。
   エラー詳細: strconv.Atoi: parsing "456円": invalid syntax
---
入力: '789'
-> 成功: 変換後の数値: 789
---

この例では、`"456円"` という文字列は数値として解釈できないため、`strconv.Atoi()` がエラーを返しています。`if err != nil` でそのエラーを検知し、ユーザーに分かりやすいメッセージを表示するなどの対応をとることができますね。

Go言語で独自のエラーを作成する方法

Goの標準ライブラリが提供してくれるエラー（ファイルが見つからない `os.ErrNotExist` など）だけでは、自分たちのアプリケーション特有の状況を表現しきれないことがあります。

例えば、「ユーザーが見つかりませんでした」とか「在庫が不足しています」のような、アプリケーション固有のエラーを扱いたい場合です。

そんなときは、自分でオリジナルのエラーを作成することができます。そのための基本的な方法が2つあります。

  1. `errors.New()` 関数を使う方法
  2. `fmt.Errorf()` 関数を使う方法

どちらも `error` インターフェースを満たす値を返してくれるので、`if err != nil` でチェックできる点は同じです。それぞれの使い方を見ていきましょう。

`errors.New` でシンプルな固定エラーを作る

`errors.New()` は、固定の文字列を持つ、シンプルなエラーを作りたいときに使います。

package main

import (
	"errors"
	"fmt"
)

// アプリケーション固有のエラーを定義
var ErrUserNotFound = errors.New("指定されたユーザーが見つかりません")

// ユーザーを探す関数 (見つからない場合は ErrUserNotFound を返す)
func findUser(id int) (string, error) {
	if id == 1 {
		return "Alice", nil // IDが1ならAliceを返す
	}
	// それ以外のIDならユーザーが見つからないエラーを返す
	return "", ErrUserNotFound 
}

func main() {
	user, err := findUser(2) // わざと見つからないIDを指定
	if err != nil {
		// ★独自エラーも同じようにチェックできる！
		if err == ErrUserNotFound { 
			fmt.Println("エラー発生！ (独自エラー)")
			fmt.Println("エラー内容:", err) 
		} else {
			fmt.Println("予期せぬエラー:", err)
		}
	} else {
		fmt.Println("ユーザーが見つかりました:", user)
	}
}

実行結果

エラー発生！ (独自エラー)
エラー内容: 指定されたユーザーが見つかりません

このように `errors.New()` で作成したエラーは、特定のエラー状況を表す定数のように使うことができます。

`if err == ErrUserNotFound` のように、返ってきたエラーが特定のエラーかどうかを比較することも可能です。

`fmt.Errorf` で書式指定して動的なエラーを作る

エラーメッセージに、エラーが発生したときの状況に応じた具体的な情報（変数の値など）を含めたい場合があります。そんなときに便利なのが `fmt.Errorf()` です。

これは、`fmt.Sprintf()` と同じように、書式指定文字列を使って動的にエラーメッセージを組み立てることができます。

package main

import (
	"fmt"
)

// 在庫を確認する関数
func checkStock(item string, requested int) error {
	available := 5 // 仮の在庫数
	if requested > available {
		// 在庫不足エラーを、具体的な情報を含めて生成
		return fmt.Errorf("在庫不足: 商品 '%s' の在庫が %d 個しかありません (要求数: %d)", item, available, requested) 
	}
	return nil // 在庫があればエラーなし
}

func main() {
	err := checkStock("リンゴ", 10) // 在庫(5個)より多い数を要求
	if err != nil {
		fmt.Println("エラー発生！")
		// エラーメッセージには状況に応じた情報が含まれている
		fmt.Println(err) 
	} else {
		fmt.Println("在庫は十分にあります。")
	}
}

実行結果

エラー発生！
在庫不足: 商品 'リンゴ' の在庫が 5 個しかありません (要求数: 10)

`fmt.Errorf` を使うと、なぜエラーになったのか、より具体的な原因をエラーメッセージに込めることができるので、デバッグがとても楽になります。

【おまけ】エラーラッピング (Go 1.13以降)
`fmt.Errorf` には `%w` という特別な書式指定子があります。これを使うと、あるエラーの中に別のエラー（根本原因のエラー）を「包み込む」ことができます。

エラーの原因を深く追跡したい場合に役立ちますが、少し発展的な内容なので、ここでは「そういう機能もあるんだな」くらいに留めておいてください。

Go言語エラーハンドリングの注意点と効果的な使い方

さて、ここまでGoのエラーハンドリングの基本を学んできました。

最後に、より良いコードを書くために、エラーハンドリングで気をつけておきたい点や、おすすめの書き方をいくつか紹介しますね！

エラーは絶対に無視しない！

関数が `error` を返す可能性がある場合、必ず受け取って `if err != nil` でチェックしましょう。エラーを無視する `_ = err` のような書き方は、意図が明確な場合（例：`defer resp.Body.Close()` のエラーを意図的に無視するなど）を除き、基本的には避けるべきです。見過ごされたエラーは、後で大きな問題を引き起こす可能性があります。

エラーを受け取ったら、すぐチェックする

エラーを返す可能性のある関数を呼び出したら、その直後に `if err != nil` でチェックするのがGoの作法です。他の処理を挟んでしまうと、エラーチェックを忘れたり、エラーの原因箇所が分かりにくくなったりします。

エラーメッセージは具体的に

特に自分でエラーを作る場合（`fmt.Errorf` など）、何が原因でエラーになったのか、後から見た人（未来の自分を含む！）にも分かるように、具体的な情報をメッセージに含めることを心がけましょう。「エラーが発生しました」だけだと、原因究明が大変です。

エラーが発生したら、早めに処理を中断する（早期リターン）

`if err != nil` のブロック内では、エラー処理（ログ出力など）を行った後、`return` や `continue`, `break` などで、それ以降の正常系の処理に進まないようにするのが一般的です。コードのネストが深くなるのを防ぎ、処理の流れが追いやすくなります。

`panic` はむやみに使わない

Goには `panic` という、プログラムを強制終了させる（正確にはパニック状態にする）仕組みもありますが、これは基本的に使いません。

`panic` は、本当にどうしようもない、回復不可能な致命的な状態（例えば、プログラムの初期設定に失敗して起動できないなど）を示すために限定的に使うべきです。通常のエラー処理には、これまで見てきた `error` インターフェースと `if err != nil` を使いましょう。

エラーに文脈（コンテキスト）を追加する

エラーを呼び出し元に返す際に、発生箇所や状況に関する情報を `fmt.Errorf` などで付け加えると、エラーの原因特定がより容易になります。（エラーラッピング `%w` もこの文脈追加の一つの方法です）

【まとめ】Go言語のエラーハンドリングをマスターへの第一歩

お疲れ様でした！ この記事では、Go言語のエラーハンドリングについて、基本的な考え方から、`error` インターフェース、定番の `if err != nil` パターン、具体的なサンプルコード、独自エラーの作り方、そして注意点まで、一通り解説してきました。

Goのエラーハンドリングは、最初は少し冗長に感じるかもしれませんが、エラーを「値」として明示的に扱うことで、コードのどこでエラーが起こりうるのか、どう対処するのかが非常に明確になるという大きなメリットがあります。

これは、プログラムの安全性を高め、チームでの開発をスムーズにするための、Go言語の重要な文化なんです。

【関連記事】 Go言語とは？特徴・できること・将来性

このブログを検索
  • ()

自己紹介

自分の写真
リモートワークでエンジニア兼Webディレクターとして活動しています。プログラミングやAIなど、日々の業務や学びの中で得た知識や気づきをわかりやすく発信し、これからITスキルを身につけたい人にも役立つ情報をお届けします。 note → https://note.com/yurufuri X → https://x.com/mnao111

QooQ