Go 公式コーディング規約とベストプラクティス

Posted at 2025-08-31

Go 言語は、その簡潔さと一貫性で知られており、公式が完全なコーディング規範ガイドを提供しています。この記事は、Effective Go や Code Review Comments などの公式ドキュメントを基に、Go 言語のコアなコーディング標準とベストプラクティスをまとめたものです。

1. コードフォーマット

Go 言語は自動化されたコードフォーマットツールを提供しており、手動でコードスタイルを調整する必要はありません：

# 単一ファイルをフォーマット
go fmt main.go

# パッケージ全体をフォーマット
go fmt ./...

# gofmt（より低レベルのツール）を使用
gofmt -w *.go

# goimports を使用（インポートを自動管理）
goimports -w *.go

核心原則：すべての Go コードは gofmt でフォーマットされるべきであり、これはコミュニティの強制的な慣習です。

2. 命名規則

Go 言語の命名規則は簡潔かつ明確であり、大文字小文字で可視性を制御します：

// パッケージ名：小文字の単語で簡潔に
package httputil

// 公開関数：先頭大文字、キャメルケースを使用
func NewClient() *Client {}

// 非公開関数：先頭小文字
func parseURL(url string) error {}

// 定数：キャメルケース、アンダースコアは使用しない
const MaxRetryCount = 3
const defaultTimeout = 30

// インターフェース名：単一メソッドインターフェースは -er 接尾辞を使用
type Reader interface {
    Read([]byte) (int, error)
}

type Writer interface {
    Write([]byte) (int, error)
}

アンダースコアや混在した大文字小文字は避け、Go 言語は短い変数名を好みます。

3. パッケージ設計の原則

良いパッケージ設計は Go プロジェクトの基盤です：

// パッケージコメント：完全な文で、パッケージ名から始める
// Package httputil provides HTTP utility functions for common web operations.
package httputil

// インポートのグループ化：標準ライブラリ、サードパーティライブラリ、ローカルパッケージ
import (
    "fmt"
    "net/http"

    "github.com/gin-gonic/gin"

    "myproject/internal/config"
)

// インターフェースは実装側ではなく利用側のパッケージで定義する
type UserService interface {
    GetUser(id int) (*User, error)
}

パッケージ名は簡潔で意味のあるものにし、util や common のような一般的すぎる名前は避けます。

4. エラーハンドリングのパターン

Go 言語におけるエラーハンドリングは、核心的な特徴のひとつです：

// 標準的なエラーハンドリングパターン
func ReadConfig(filename string) (*Config, error) {
    data, err := os.ReadFile(filename)
    if err != nil {
        return nil, fmt.Errorf("reading config file: %w", err)
    }

    var config Config
    if err := json.Unmarshal(data, &config); err != nil {
        return nil, fmt.Errorf("parsing config: %w", err)
    }

    return &config, nil
}

// エラーハンドリングを優先して入れ子を減らす
func ProcessFile(filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer file.Close()

    // 正常な処理
    return processData(file)
}

エラーを無視してはいけません。エラーのラップには fmt.Errorf と %w 動詞を使用し、エラーチェーンを保持します。

5. 関数とメソッド設計

Go 言語は簡潔な関数設計を推奨しています：

// レシーバー名：短く一貫性のあるものにする
type User struct {
    Name string
    Age  int
}

// 値レシーバー：レシーバーを変更しない場合に使用
func (u User) String() string {
    return fmt.Sprintf("%s (%d)", u.Name, u.Age)
}

// ポインタレシーバー：レシーバーを変更する場合に使用
func (u *User) UpdateAge(age int) {
    u.Age = age
}

// 複数戻り値：エラーは常に最後の戻り値とする
func ParseUser(data []byte) (User, error) {
    var u User
    err := json.Unmarshal(data, &u)
    return u, err
}

関数シグネチャは簡潔に保ち、引数を増やしすぎないようにします。複雑な引数は構造体を使って渡すことを検討してください。

6. 並行プログラミング規範

Go 言語の並行モデルは goroutine と channel に基づいています：

// goroutine のライフサイクルを明確にする
func processData(ctx context.Context, data <-chan string) <-chan Result {
    results := make(chan Result)

    go func() {
        defer close(results)
        for {
            select {
            case item := <-data:
                if item == "" {
                    return
                }
                results <- process(item)
            case <-ctx.Done():
                return
            }
        }
    }()

    return results
}

// context を使って goroutine を制御する
func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    data := make(chan string, 10)
    results := processData(ctx, data)

    // 結果を利用...
}

goroutine のリークを避けるため、終了条件を明確に定義することが重要です。

7. コメント規範

Go 言語のコメントには特定のフォーマット要件があります：

// Package math provides basic mathematical functions.
package math

// Pi represents the mathematical constant π.
const Pi = 3.14159265358979323846

// Sqrt returns the square root of x.
// It panics if x is negative.
func Sqrt(x float64) float64 {
    if x < 0 {
        panic("math: square root of negative number")
    }
    // 実装...
    return 0
}

公開された名前には必ずコメントをつける必要があります。コメントは完全な文で書き、コメント対象の名前から始めるべきです。

8. テスト規範

Go 言語はテストを標準でサポートしており、特定の命名と構造規則に従います：

// user_test.go
func TestUser_UpdateAge(t *testing.T) {
    tests := []struct {
        name     string
        user     User
        newAge   int
        expected int
    }{
        {"update age", User{"Alice", 25}, 30, 30},
        {"zero age", User{"Bob", 20}, 0, 0},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            tt.user.UpdateAge(tt.newAge)
            if tt.user.Age != tt.expected {
                t.Errorf("UpdateAge() = %d, want %d", tt.user.Age, tt.expected)
            }
        })
    }
}

テーブル駆動テストを使い、明確なエラーメッセージを提供することを推奨します。

9. パフォーマンス最適化の指針

Go 言語のパフォーマンス最適化の原則：

// slice 容量を事前に確保して複数回の再割り当てを避ける
func processItems(items []string) []Result {
    results := make([]Result, 0, len(items))  // 容量を事前確保
    for _, item := range items {
        results = append(results, process(item))
    }
    return results
}

// string builder を使って効率的に文字列を構築する
func buildMessage(parts []string) string {
    var builder strings.Builder
    builder.Grow(estimateSize(parts))  // 容量を見積もる

    for _, part := range parts {
        builder.WriteString(part)
    }
    return builder.String()
}

まず正しいコードを書くことを優先し、その後パフォーマンス最適化を行います。ボトルネックの分析には pprof などのツールを使用します。

まとめ

Go 言語のコーディング規範は、「複雑さよりも簡潔さ」を重視する設計哲学を体現しています。gofmt や goimports などの公式ツールを利用し、Effective Go のガイドラインに従い、Code Review Comments の具体的な提案を参考にすることで、Go 言語の習慣に沿った高品質なコードを書くことができます。これらの規範はコードの可読性と保守性を高めるだけでなく、Go 言語コミュニティ全体のコードスタイルの一貫性を確保します。