Какие у тебя критерии хорошего кода?

Критерии хорошего кода в Go

Хороший код — это не только функциональность, но и совокупность характеристик, обеспечивающих долгосрочную поддерживаемость, эффективность и безопасность проекта. В контексте Go, как языка с сильной акцентом на простоту и практичность, мои критерии включают следующие ключевые аспекты.

1. Читаемость и понятность

Код должен быть легко читаемым и понятным для других разработчиков (и для автора в будущем). Это достигается через:

• Именование: использование clear и meaningful имен переменных, функций и типов согласно соглашениям Go (camelCase для локальных, PascalCase для публичных).
• Простая структура: избегание чрезмерной сложности; каждый блок кода (функция, метод) должен выполнять одну четкую задачу.
• Комментарии: добавление комментариев для объяснения сложной логики или внешних зависимостей, но не для очевидных операций.

// Плохо: непонятное имя и сложная логика
func process(d []int) []int {
    var r []int
    for i := range d {
        if i%2 == 0 {
            r = append(r, d[i]*2)
        }
    }
    return r
}

// Хорошо: ясное имя и простая функция
func FilterAndDoubleEvenNumbers(numbers []int) []int {
    var result []int
    for index, value := range numbers {
        if index%2 == 0 {
            result = append(result, value*2)
        }
    }
    return result
}

2. Эффективность и производительность

Go часто используется для высоконагруженных систем, поэтому эффективность важна:

• Минимизация аллокаций памяти: использование предварительно выделенных буферов (make с заданной capacity), избегание лишних копий.
• Оптимизация алгоритмов: выбор подходящих структур данных (например, map для поиска вместо списка).
• Конкурентность правильно: применение goroutines, channels и sync механизмов без излишнего усложнения.

// Эффективное предварительное выделение памяти
func ProcessLargeDataset(items []Item) []Result {
    results := make([]Result, 0, len(items)) // capacity = len, минимизирует reallocation
    for _, item := range items {
        results = append(results, compute(item))
    }
    return results
}

3. Тестируемость и поддерживаемость

Код должен быть легко тестируемым и адаптируемым к изменениям:

• Разделение ответственности: модульная архитектура с использованием интерфейсов для абстракции.
• Малое количество зависимостей: функции и методы должны зависеть от минимального числа внешних состояний.
• Покрытие тестами: наличие unit-тестов для критических логик, использование табличных тестов (table-driven tests) в Go.

// Тестируемая функция с чистой логикой
func CalculateDiscount(price float64, discountRate float64) float64 {
    if discountRate < 0 || discountRate > 1 {
        return price
    }
    return price * (1 - discountRate)
}

// Table-driven test для этой функции
func TestCalculateDiscount(t *testing.T) {
    tests := []struct {
        name         string
        price        float64
        discountRate float64
        expected     float64
    }{
        {"Valid discount", 100.0, 0.1, 90.0},
        {"No discount", 100.0, 0.0, 100.0},
        {"Invalid negative rate", 100.0, -0.1, 100.0},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result := CalculateDiscount(tt.price, tt.discountRate)
            if result != tt.expected {
                t.Errorf("got %v, want %v", result, tt.expected)
            }
        })
    }
}

4. Соответствие стандартам языка и экосистемы

Go имеет мощную экосистему и строгие соглашения:

• Форматирование: использование gofmt для обеспечения единого стиля.
• Обработка ошибок: явная обработка ошибок, без игнорирования возвращаемых error значений.
• Использование инструментов: применение go vet, staticcheck для анализа кода, линтеров для соблюдения best practices.

// Правильная обработка ошибок
func ReadConfig(path string) (*Config, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("reading config: %w", err) // wrapping error
    }
    var config Config
    if err := json.Unmarshal(data, &config); err != nil {
        return nil, fmt.Errorf("parsing config: %w", err)
    }
    return &config, nil
}

5. Безопасность и надежность

Код должен быть устойчивым к ошибкам и безопасным:

• Проверка границ: избегание падений из-за out-of-range access в массивах и слайсах.
• Конкурентная безопасность: защита данных при использовании goroutines через mutexes или channels.
• Валидация входных данных: проверка внешних входов (аргументов, данных от пользователя).

6. Практичность и баланс

В Go особенно ценится прагматизм: не стремиться к идеальной абстракции, если это усложняет код. Иногда простой, прямой код лучше излишне "умного". Критерии применяются контекстно: для высокочастотного микросервиса важнее эффективность, для библиотеки — читаемость и тестируемость.

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