Go言語のinit関数：実行順序の仕組みと誤用を防ぐ実務的活用術

2026年5月7日2026年5月8日

関数・インターフェース・ジェネリクス

Goプログラミングにおいて、プログラムの起動時に特定の処理を自動的に実行させる「init関数」は、非常に強力かつユニークな存在です。

しかし、その強力さゆえに、動作の仕組みを正しく理解していないと、意図しない実行順序によるバグや、コードの可読性を著しく低下させる要因にもなり得ます。

2026年現在のモダンなGo開発では、暗黙的な処理をいかに制御し、明示的な設計を保つかが重要視されています。

本記事では、init関数の実行メカニズムから、実務で役立つ具体的な活用術、そして陥りやすいアンチパターンとその回避策までを詳しく掘り下げていきます。

目次 [ close ]

init関数の基本仕様と役割

init関数は、Goランタイムがプログラムの実行を開始する際に、main関数よりも先に自動で呼び出される特殊な関数です。

通常の関数とは異なり、引数を取ることも、戻り値を返すこともできません。

また、プログラム内の任意の場所から明示的に呼び出すことも禁止されています。

init関数の定義方法

init関数の定義は非常にシンプルです。

識別子としてinitという名前を使用するだけで、特別な設定は不要です。

package main

import "fmt"

// init関数はmain関数より先に実行される
func init() {
	fmt.Println("init: 初期化処理を実行します")
}

func main() {
	fmt.Println("main: メイン処理を開始します")
}

実行結果

init: 初期化処理を実行します
main: メイン処理を開始します

このように、開発者が意識して呼び出すことなく、パッケージがロードされたタイミングで確実に実行されるのがinit関数の最大の特徴です。

1つのファイル・パッケージに複数のinit関数

Goの興味深い仕様として、1つのソースファイル内に複数のinit関数を定義できる点、および1つのパッケージ内に複数のinit関数が点在できる点が挙げられます。

これらは、ソースコードに記述された順番に従って、上から順に実行されます。

package main

import "fmt"

func init() {
	fmt.Println("初期化1")
}

func init() {
	fmt.Println("初期化2")
}

func main() {
	fmt.Println("メイン")
}

実行結果

初期化1
初期化2
メイン

複数のファイルに分かれている場合は、ビルドツールに渡されるファイル名のアルファベット順に実行されるのが一般的ですが、この順序に依存した実装はメンテナンス性を損なうため、避けるべきとされています。

init関数の実行順序：詳細メカニズム

複雑な依存関係を持つプロジェクトにおいて、init関数が「いつ」実行されるのかを正確に把握することは、デバッグやアーキテクチャ設計において極めて重要です。

Goの実行順序は、言語仕様によって厳密に定義されています。

パッケージ変数とinit関数の関係

まず理解しておくべきは、パッケージレベルで宣言された変数の初期化とinit関数の関係です。

実行順序は以下のルールに従います。

インポートされたパッケージが順次初期化される（再帰的）。
パッケージ内の定数・変数が初期化される。
パッケージ内のinit関数が実行される。

以下のコードでその挙動を確認してみましょう。

package main

import "fmt"

var (
	// 変数初期化で関数を呼び出す
	_ = initializeVariable()
)

func initializeVariable() int {
	fmt.Println("1. パッケージ変数の初期化")
	return 0
}

func init() {
	fmt.Println("2. init関数の実行")
}

func main() {
	fmt.Println("3. main関数の実行")
}

実行結果

1. パッケージ変数の初期化
2. init関数の実行
3. main関数の実行

パッケージ間の依存関係による実行順序

複数のパッケージが絡む場合、Goは依存グラフの下層（他のパッケージに依存していないパッケージ）から順に初期化を行います。

例えば、mainがpkgAをインポートし、pkgAがpkgBをインポートしている場合、実行順序は pkgB -> pkgA -> main となります。

順序	対象	内容
1	`pkgB`の変数	最下層パッケージの初期化開始
2	`pkgB`のinit
3	`pkgA`の変数	`pkgB`に依存しているパッケージの初期化
4	`pkgA`のinit
5	`main`の変数	エントリポイントパッケージの初期化
6	`main`のinit
7	`main`関数	プログラムのメインロジック開始

この順序は決定論的であり、一度解決されたパッケージが二度初期化されることはありません（シングルトン的な振る舞い）。

実務におけるinit関数の適切な活用パターン

init関数は、正しく使えばコードを簡潔にし、ボイラープレート（定型文）を減らすことができます。

2026年の現場でも推奨される主なパターンは以下の通りです。

1. グローバルな設定や状態の検証

プログラムが動作するために必須となる環境変数のチェックや、設定ファイルのバリデーションに利用します。

もし必須条件が満たされていない場合に、panicを発生させてプログラムを早期終了（フェイルファスト）させることができます。

package config

import (
	"os"
	"log"
)

var ApiKey string

func init() {
	ApiKey = os.Getenv("SERVICE_API_KEY")
	if ApiKey == "" {
		log.Fatal("環境変数 SERVICE_API_KEY が設定されていません。")
	}
}

2. データベースドライバ等のレジストリ登録

Goの標準ライブラリである database/sql などでよく見られるパターンです。

インポートするだけでドライバを登録する場合、init関数内でレジストリへの登録処理を行います。

package mydriver

import "database/sql"

func init() {
	sql.Register("mydriver", &MyDriver{})
}

利用側では、以下のように「ブランクインポート（_）」を用いることで、パッケージ内の識別子を直接参照せずに、init関数だけを実行させることができます。

import _ "path/to/mydriver"

3. 重い定数計算の事前実行

実行時に計算するとコストが高い複雑な正規表現のコンパイルや、静的なテーブルデータの生成などをinit関数で行い、グローバル変数に保持しておく手法です。

これにより、初回リクエスト時のレイテンシを削減できます。

var complexRegex *regexp.Regexp

func init() {
	// 重いコンパイル処理を起動時に一度だけ行う
	complexRegex = regexp.MustCompile(`^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}$`)
}

init関数の使用を避けるべきケースとアンチパターン

強力なinit関数ですが、多用すると「マジック（魔法）」が増えすぎ、コードの追跡が困難になります。

以下の状況では、init関数の使用を慎重に検討するか、代替手段を探すべきです。

1. 外部リソースへの接続（DB・ネットワーク）

init関数内でデータベースに接続したり、API通信を行ったりすることは避けるべきです。

理由は以下の3点です。

テストが困難になる：パッケージをインポートしただけでDB接続が試行されるため、ユニットテストの実行環境構築が難しくなります。
エラーハンドリングが制限される：init関数は値を返せないため、エラーが発生しても panic させるかログを出すしかありません。
起動時間の増大：接続待ちが発生すると、プログラムの起動自体が極端に遅くなります。

このような場合は、明示的な NewClient() 関数や Initialize() 関数を用意し、main関数から呼び出す設計が推奨されます。

2. init関数間での暗黙的な依存

「ファイルAのinit関数が、ファイルBのinit関数でセットされた値を参照している」といった状態は、非常に危険です。

前述の通り、ファイル間の実行順序はファイル名などに依存するため、ファイル名の変更だけでプログラムが壊れる可能性があります。

3. グローバル変数の乱用

init関数はグローバル変数を操作するために使われることが多いですが、これは隠れた状態（Hidden State）を生み出します。

コードの各所から参照されるグローバル変数がinit関数で書き換えられると、データ競合（データレース）の原因や、副作用の特定を困難にします。

2026年のベストプラクティス：init関数とどう向き合うか

現代のGo開発では、「明示性は隠黙に勝る」という原則がより強調されています。

init関数の使用を最小限に抑えるためのテクニックをいくつか紹介します。

代替案1：sync.Onceによる遅延初期化

初期化処理を「最初に使用される瞬間まで遅らせる」方法です。

これにより、プログラムの起動時間を短縮しつつ、スレッドセーフな初期化を保証できます。

var (
	instance *Service
	once     sync.Once
)

func GetService() *Service {
	once.Do(func() {
		// 必要になったタイミングで一度だけ実行される
		instance = &Service{...}
	})
	return instance
}

代替案2：明示的な初期化関数の呼び出し

特にビジネスロジックに近い部分では、main.go から明示的に初期化フローを記述するのが最も健全です。

func main() {
	ctx := context.Background()
	
	cfg, err := config.Load()
	if err != nil {
		log.Fatalf("failed to load config: %v", err)
	}

	db, err := database.Connect(ctx, cfg.DBURL)
	if err != nil {
		log.Fatalf("failed to connect db: %v", err)
	}
	defer db.Close()

	// 以降、メインロジック
}

このように構築することで、依存関係が可視化され、テスト時にはモックを注入しやすくなります。

それでもinit関数を使うべき時

副作用のみを目的とするインポート（前述のドライバ登録など）。
不変なデータのセットアップ（プログラム実行中に変化しない定数的なグローバル変数の初期化）。
標準ライブラリとの統合（一部のプロファイリングツールやトレースツールの初期化）。

これらに限定することで、init関数のメリットを享受しつつ、デメリットを最小化できます。

デバッグと実行順序の確認方法

もしinit関数の実行順序に起因すると思われる不具合に遭遇した場合、以下の手法でデバッグが可能です。

ログの挿入：単純ですが、各パッケージのinit関数内に fmt.Printf を入れることで、実際のロード順序を可視化できます。
go listコマンドの活用：go list -f '{{.Imports}}' package_name を実行することで、パッケージの依存関係を確認できます。
静的解析ツールの利用：golangci-lint などのリンターを導入し、複雑すぎるinit関数や、不適切なグローバル変数操作を検知するように設定します。

特に、2026年時点の高度な静的解析ツールでは、init関数内での外部通信を検知して警告を出す機能も一般的になっています。

これらを活用して、コード品質を維持しましょう。

まとめ

Go言語のinit関数は、初期化処理を自動化するための強力なフックですが、その「暗黙的」な性質を理解せずに利用すると、保守性の低いコードを生む原因となります。

実行順序は「インポート順」と「依存関係の深さ」によって決定される。
活用シーンは、環境変数チェックやドライバ登録、静的なデータ初期化に留める。
DB接続や複雑なロジックはinit関数に書かず、明示的な初期化関数を設計する。

Goの哲学である「シンプルで予測可能」なコードを目指すなら、init関数は慎重に、かつ限定的に使用するのが正解です。

正しく制御された初期化プロセスを構築し、堅牢なGoアプリケーションを開発していきましょう。