Go Design Patterns & Idioms

Освойте идиоматическую разработку на Go с помощью этого навыка для Claude Code. Автоматически реализуйте функциональные опции, паттерны конкурентности и чистую архитектуру Go-проектов.

Разработка API ★ 172,651 GitHub (172,651 ★)

Этот навык предоставляет Claude комплексную основу для разработки на Go, выходящую за рамки общего программирования и охватывающую такие специализированные идиомы, как functional options, малые интерфейсы и внедрение зависимостей. Он позволяет ИИ проектировать надежные конкурентные системы с использованием worker pools и контекстной передачи данных, поддерживая стандартизированную организацию пакетов и table-driven тестирование. Навык необходим разработчикам, стремящимся выйти за рамки базового синтаксиса и писать идиоматичные высокопроизводительные приложения на Go, соответствующие установленным стандартам сообщества.

Ключевые особенности

01Стандартизированная организация пакетов Go по схеме cmd/internal/pkg

02172 651 звезда на GitHub

03Functional options для гибкой и обратно совместимой настройки API

04Принципы проектирования на основе интерфейсов для слабой связанности и упрощённого мокирования

05Table-driven тестирование и реализации вспомогательных тестов для надёжной верификации

06Шаблоны конкурентных worker pool и контекстной передачи данных для предотвращения утечек

Примеры использования

01Создание новых микросервисов на Go с идиоматическим внедрением зависимостей и структурой

02Реализация безопасных и масштабируемых шаблонов конкурентности для высоконагруженных систем

03Рефакторинг монолитных проектов Go в чистые, поддерживаемые внутренние пакеты

name

golang-patterns

description

Go-specific design patterns and best practices including functional options, small interfaces, dependency injection, concurrency patterns, error handling, and package organization. Use when working with Go code to apply idiomatic Go patterns.

metadata

origin

globs

ECC

**/*.go

**/go.mod

**/go.sum

Go Patterns

This skill provides comprehensive Go patterns extending common design principles with Go-specific idioms.

Functional Options

Use the functional options pattern for flexible constructor configuration:

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
}

Benefits:

Backward compatible API evolution
Optional parameters with defaults
Self-documenting configuration

Small Interfaces

Define interfaces where they are used, not where they are implemented.

Principle: Accept interfaces, return structs

// Good: Small, focused interface defined at point of use
type UserStore interface {
    GetUser(id string) (*User, error)
}

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

Benefits:

Easier testing and mocking
Loose coupling
Clear dependencies

Dependency Injection

Use constructor functions to inject dependencies:

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

Pattern:

Constructor functions (New* prefix)
Explicit dependencies as parameters
Return concrete types
Validate dependencies in constructor

Concurrency Patterns

Worker Pool

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)
}

Context Propagation

Always pass context as first parameter:

func FetchUser(ctx context.Context, id string) (*User, error) {
    // Check context cancellation
    select {
    case <-ctx.Done():
        return nil, ctx.Err()
    default:
    }
    // ... fetch logic
}

Error Handling

Error Wrapping

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

Custom Errors

type ValidationError struct {
    Field string
    Msg   string
}

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

Sentinel Errors

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

// Check with errors.Is
if errors.Is(err, ErrNotFound) {
    // handle not found
}

Package Organization

Structure

project/
├── cmd/              # Main applications
│   └── server/
│       └── main.go
├── internal/         # Private application code
│   ├── domain/       # Business logic
│   ├── handler/      # HTTP handlers
│   └── repository/   # Data access
└── pkg/              # Public libraries

Naming Conventions

Package names: lowercase, single word
Avoid stutter: user.User not user.UserModel
Use internal/ for private code
Keep main package minimal

Testing Patterns

Table-Driven Tests

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)
            }
        })
    }
}

Test Helpers

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
}

When to Use This Skill

Designing Go APIs and packages
Implementing concurrent systems
Structuring Go projects
Writing idiomatic Go code
Refactoring Go codebases

Что это 🧩

Этот навык — справочник и код-ревьюер по идиоматическому Go. Он помогает писать код, который будет легко читать, тестировать и поддерживать, следуя общепринятым практикам сообщества Golang. Навык охватывает ключевые паттерны: функциональные опции, маленькие интерфейсы, внедрение зависимостей, параллелизм, обработку ошибок и организацию пакетов.

Как работает 🛠️

Функциональные опции (Functional Options)

Паттерн для гибкой конфигурации конструкторов без раздувания сигнатуры. Вы определяете тип Option как функцию, меняющую структуру, и применяете вариативный список опций внутри New*.

Пример:

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)
    // ...
}

Внедрение зависимостей (Dependency Injection) 💉

Зависимости явно передаются в конструктор с префиксом New*. Конструктор принимает интерфейсы (или конкретные типы), возвращает конкретную структуру, часто с валидацией зависимостей на месте.

Пример:

func NewUserService(repo UserRepository, logger Logger) *UserService {
    if repo == nil || logger == nil {
        panic("dependencies must not be nil")
    }
    return &UserService{repo: repo, logger: logger}
}

Паттерны параллелизма ⚡

Навык предлагает две ключевые техники:

Worker Pool — фиксированное количество горутин параллельно обрабатывают задания из канала jobs и пишут результаты в results. Используется sync.WaitGroup для синхронизации.
Контекст — всегда передаётся первым аргументом (ctx context.Context). Перед началом долгой операции проверяется ctx.Done(), чтобы корректно отменять работу.

Обработка ошибок ⚠️

Три основных подхода:

Оборачивание ошибок через fmt.Errorf("...: %w", err) — сохраняет исходную ошибку для errors.Is и errors.As.
Кастомные типы ошибок — структура с полями (например, ValidationError), реализующая интерфейс error.
Sentinel-ошибки — глобальные переменные-ошибки (например, ErrNotFound), которые сравниваются через errors.Is.

Организация пакетов 📁

Типовая структура Go-проекта:

project/
├── cmd/              # Точки входа (main)
├── internal/         # Приватный код приложения
│   ├── domain/       # Бизнес-логика
│   ├── handler/      # HTTP-обработчики
│   └── repository/   # Доступ к данным
└── pkg/              # Публичные библиотеки

Правила именования:

Имена пакетов — одно слово, нижний регистр.
Без статтера: user.User, а не user.UserModel.
internal/ — для кода, который не должен быть импортирован извне.
main — минимальный, только запуск сервера.

Тестирование 🧪

Два основных шаблона:

Table-driven tests — слайс структур с полями name, input, wantErr (или expected), запускаемый через t.Run.
Test helpers — функции, создающие окружение (например, тестовую БД) с вызовом t.Helper() и t.Cleanup() для автоматической очистки.

Когда использовать 🔍

Ты проектируешь новое Go-API или библиотеку.
Нужно написать надёжную параллельную обработку.
Рефакторишь большую кодовую базу на Go, чтобы привести её к идиоматичному стилю.
Готовишься к код-ревью и хочешь следовать best practices.
Создаёшь структуру многопакетного проекта.

Важно знать ⚡

Навык не заменяет полную документацию по пакету (например, не описывает все нюансы context или errors). Это именно практические шаблоны.
internal/ — не просто соглашение: на уровне компилятора Go запрещает импорт из внешних пакетов.
Sentinel-ошибки лучше объявлять как var, а не const, и использовать только для ошибок без динамических данных. Для ошибок с контекстом (поля, параметры) подходят кастомные типы.
В тестах t.Helper() помечает функцию как вспомогательную: при падении стектрейс укажет на строку вызова, а не на тело helper'а.
Комментарии к экспортируемым функциям, интерфейсам и типам обязательны (godoc). Навык этого не показывает, но подразумевает.

Установка одной командой.

npx skillfish add affaan-m/everything-claude-code golang-patterns

Источник: https://mcpmarket.com/tools/skills/go-design-patterns-idioms

Go Design Patterns & Idioms

Ключевые особенности

Примеры использования

Go Patterns

Functional Options

Small Interfaces

Dependency Injection

Concurrency Patterns

Worker Pool

Context Propagation

Error Handling

Error Wrapping

Custom Errors

Sentinel Errors

Package Organization

Structure

Naming Conventions

Testing Patterns

Table-Driven Tests

Test Helpers

When to Use This Skill

Что это 🧩

Как работает 🛠️

Функциональные опции (Functional Options)

Маленькие интерфейсы 🗂️

Внедрение зависимостей (Dependency Injection) 💉

Паттерны параллелизма ⚡

Обработка ошибок ⚠️

Организация пакетов 📁

Тестирование 🧪

Когда использовать 🔍

Важно знать ⚡

Совместимо ли это умение с современной обработкой ошибок в Go?

Включает ли оно лучшие практики тестирования для Golang?

Как этот навык улучшает качество моего Go-кода?

Может ли он помочь с организацией Go-проекта?

Поддерживает ли он сложные паттерны конкурентности в Go?

Комментарии