Условные операторы в Go

Начало работы с Go

Если вы ещё не установили Go, скачайте и установите его с официального сайта golang.org или используйте Go playground для быстрого тестирования фрагментов кода. Минимальная терминология:

• Компилятор: программа, собирающая ваш код в исполняемый файл.
• Package main: начальная точка программы в Go.

Оператор if

Оператор if выполняет блок кода, если проверяемое условие истинно.

Синтаксис:

if condition {
    // Блок кода
}

Пример: печать «Pass», если значение marks больше 50.

marks := 60

if marks > 50 {
    fmt.Println("Pass")
}

Можно объявить переменную прямо в условии:

if marks := 60; marks > 50 {
    fmt.Println("Pass")
}

Комбинирование условий: Go использует знакомые логические операторы AND (&&), OR (||) и NOT (!).

AND возвращает true только если оба операнда истинны:

sunny := true
noClass := true

if sunny && noClass {
    fmt.Println("Go to the beach")
}

OR возвращает true если хотя бы один операнд истинен:

today := "Sunday"

if today == "Sunday" || today == "Saturday" {
    fmt.Println("Sleep in")
}

NOT инвертирует логическое значение:

marksAvailable := false

if !marksAvailable {
    fmt.Println("No marks available!")
}

if…else

if…else выполняет один из двух блоков в зависимости от условия.

if condition {
    // Если условие истинно
} else {
    // Если условие ложно
}

Пример:

marks := 60

if marks > 50 {
    fmt.Println("Pass")
} else {
    fmt.Println("Fail")
}

if…else if…else

Если нужно проверить несколько ветвей, используйте последовательность if — else if — else.

if condition1 {
    // Если condition1 истинно
} else if condition2 {
    // Если condition2 истинно
} else {
    // Ни одно условие не выполнено
}

Пример с оценками:

marks := 60

if marks > 80 {
    fmt.Println("Passed with distinction")
} else if marks > 50 {
    fmt.Println("Pass")
} else {
    fmt.Println("Fail")
}

Оператор switch

switch позволяет выполнить разные действия в зависимости от значения выражения. В Go switch по умолчанию не «проваливается» (no implicit fallthrough): выполняется только совпавший case. Для явного перехода используется ключевое слово fallthrough.

Синтаксис:

switch expression {
case expr1:
    // Блок кода
case expr2:
    // Блок кода
default:
    // Блок кода
}

Пример: действие для каждого дня недели. Здесь используем константы пакета time для ясности.

package main

import (
    "fmt"
    "time"
)

func main() {
    today := time.Now().Weekday()

    switch today {
    case time.Sunday:
        fmt.Println("Relax.")
    case time.Monday:
        fmt.Println("Clean the house.")
    case time.Tuesday:
        fmt.Println("Visit the dentist.")
    case time.Wednesday:
        fmt.Println("Weed the garden.")
    case time.Thursday:
        fmt.Println("Send gifts")
    case time.Friday:
        fmt.Println("Do laundry.")
    case time.Saturday:
        fmt.Println("Write a blog post.")
    default:
        fmt.Println("No task scheduled.")
    }
}

Важно: значения case должны быть сравнимы с выражением switch. В Go нет автоматического «проваливания» между case, и break не нужен. Для перехода используется fallthrough, который выполняет следующий case независимо от его условия.

Когда использовать условные операторы

Условные операторы применяются, когда поведение программы зависит от значений: пользовательский ввод, состояния, ответы от API, ошибки и т. п. Они создают ветвящуюся логику и управляют потоком выполнения.

Частые ошибки и подводные камни

• Использование неверного типа в case для switch. Сравнивайте совместимые типы или используйте константы из соответствующего пакета.
• Ожидание автоматического fallthrough: в Go case не «проваливается» по умолчанию.
• Слишком длинные вложенные if: ухудшают читаемость. Рассмотрите ранний return или выделение логики в функции.
• Сравнение float64 на равенство: избегайте точного сравнения, используйте дельту.
• Объявление переменных внутри if ограничивает их область видимости телом if.

Important: избегайте глубокой вложенности — предпочитайте guard clauses (ранний return) и вынос логики в функции.

Альтернативные подходы

• Таблица переходов (map[Key]func()): удобно для замены длинного switch по значениям, особенно для действий.
• Полиморфизм/интерфейсы: вместо ветвлений по типу объекта реализуйте поведение через интерфейсы.
• Стратегия или шаблон «Команда»: упаковка поведения в отдельные объекты-функции.

Пример замены switch на map:

actions := map[string]func(){
    "start": func() { fmt.Println("Starting") },
    "stop":  func() { fmt.Println("Stopping") },
}

if act, ok := actions[cmd]; ok {
    act()
} else {
    fmt.Println("Unknown command")
}

Шпаргалка (cheat sheet)

• if condition { … } — базовый блок ветвления.
• if v := expr; v > x { … } — объявление переменной в условии.
• if a && b || c — сочетание логики (соблюдайте приоритеты).
• switch value { case v1, v2: … } — несколько значений в одном case.
• fallthrough — принудительное выполнение следующего case.

Чек-листы по ролям

Разработчик:

• Проверить типы данных при сравнении.
• Избегать дублирования кода в ветвях.
• Добавить тесты для каждой ветви логики.

Код-ревьювер:

• Убедиться, что вложенность не превышает читаемости.
• Проверить использование констант и enum-подобных типов.
• Оценить целесообразность замены на таблицу dispatch.

Тестировщик:

• Разработать тесты для позитивных и негативных ветвей.
• Проверить граничные случаи и неожиданные типы.

Минимальный набор тестов (критерии приёмки)

• Для if/else: поведение при true и false.
• Для многоветвевого if: каждая ветвь покрыта тестом.
• Для switch: тесты на совпадающие case и default.
• Для map-dispatch: существующий и несуществующий ключи.

Краткий глоссарий (1 строка)

• if: базовый условный оператор в Go.
• switch: множественный выбор по значению выражения.
• fallthrough: принудительный переход к следующему case.
• guard clause: ранний выход из функции для уменьшения вложенности.

Когда условные операторы не подходят

• Когда поведение лучше выразить через полиморфизм или интерфейсы.
• Когда много похожих условий — лучше использовать таблицу соответствий.

Заключение

Условные операторы — базовый инструмент управления потоком в Go. Используйте простую и понятную структуру, избегайте глубокой вложенности, рассматривайте альтернативы (map, интерфейсы) при увеличении числа ветвей. Добавьте юнит-тесты для каждого сценария и предпочитайте явность — это улучшает поддержку кода.

Краткое резюме на случай быстрого прочтения: используйте if для простых проверок, if…else для двух ветвей, if…else if…else для нескольких условий и switch для выбора по значению; в сложных случаях подумайте о map-dispatch или интерфейсах.