Go パターン

このスキルは、Go固有のイディオムで一般的な設計原則を拡張した包括的なGoパターンを提供します。

関数型オプション

柔軟なコンストラクタ設定には関数型オプションパターンを使用します:

type Option func(*Server)

func WithPort(port int) Option {
    return func(s *Server) { s.port = port }
}

func NewServer(opts ...Option) *Server {
    s := &Server{port: 8080}
    for _, opt := range opts {
        opt(s)
    }
    return s
}

利点:

• APIの後方互換性のある進化
• デフォルト値付きのオプションパラメータ
• 自己記述的な設定

小規模なインターフェース

インターフェースは実装される場所ではなく、使用される場所で定義します。

原則: インターフェースを受け入れ、構造体を返す

// 良い例: 使用場所で定義された小規模で焦点を絞ったインターフェース
type UserStore interface {
    GetUser(id string) (*User, error)
}

func ProcessUser(store UserStore, id string) error {
    user, err := store.GetUser(id)
    // ...
}

利点:

• テストとモッキングが容易
• 疎結合
• 依存関係が明確

依存性の注入

コンストラクタ関数を使用して依存関係を注入します:

func NewUserService(repo UserRepository, logger Logger) *UserService {
    return &UserService{
        repo:   repo,
        logger: logger,
    }
}

パターン:

• コンストラクタ関数 (New* プレフィックス)
• パラメータとしての明示的な依存関係
• 具体的な型を返す
• コンストラクタで依存関係を検証

並行処理パターン

ワーカープール

func workerPool(jobs <-chan Job, results chan<- Result, workers int) {
    var wg sync.WaitGroup
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {
                results <- processJob(job)
            }
        }()
    }
    wg.Wait()
    close(results)
}

コンテキストの伝播

常にコンテキストを最初のパラメータとして渡します:

func FetchUser(ctx context.Context, id string) (*User, error) {
    // コンテキストのキャンセルを確認
    select {
    case <-ctx.Done():
        return nil, ctx.Err()
    default:
    }
    // ... フェッチロジック
}

エラーハンドリング

エラーのラッピング

if err != nil {
    return fmt.Errorf("failed to fetch user %s: %w", id, err)
}

カスタムエラー

type ValidationError struct {
    Field string
    Msg   string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("%s: %s", e.Field, e.Msg)
}

センチネルエラー

var (
    ErrNotFound = errors.New("not found")
    ErrInvalid  = errors.New("invalid input")
)

// errors.Is で確認
if errors.Is(err, ErrNotFound) {
    // 見つからない場合の処理
}

パッケージの構成

構造

project/
├── cmd/              # メインアプリケーション
│   └── server/
│       └── main.go
├── internal/         # プライベートアプリケーションコード
│   ├── domain/       # ビジネスロジック
│   ├── handler/      # HTTPハンドラー
│   └── repository/   # データアクセス
└── pkg/              # パブリックライブラリ

命名規則

• パッケージ名: 小文字、単語1つ
• スタッターを避ける: user.User ではなく user.UserModel
• プライベートコードには internal/ を使用
• main パッケージは最小限に

テストパターン

テーブル駆動テスト

func TestValidate(t *testing.T) {
    tests := []struct {
        name    string
        input   string
        wantErr bool
    }{
        {"valid", "test@example.com", false},
        {"invalid", "not-an-email", true},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            err := Validate(tt.input)
            if (err != nil) != tt.wantErr {
                t.Errorf("got error %v, wantErr %v", err, tt.wantErr)
            }
        })
    }
}

テストヘルパー

func testDB(t *testing.T) *sql.DB {
    t.Helper()
    db, err := sql.Open("sqlite3", ":memory:")
    if err != nil {
        t.Fatalf("failed to open test db: %v", err)
    }
    t.Cleanup(func() { db.Close() })
    return db
}

このスキルを使用する場合

• Go APIとパッケージの設計
• 並行システムの実装
• Goプロジェクトの構成
• イディオマティックなGoコードの作成
• Goコードベースのリファクタリング