2.3 🔀 Управляющие структуры

💬 Что это вообще такое? Управляющие структуры — это конструкции, которые позволяют управлять ходом выполнения программы. Благодаря им, мы можем сказать компьютеру: «если A, то сделай B», или «выполняй C до тех пор, пока не станет D».

В повседневной жизни ты тоже используешь такую логику:

Если идёт дождь — берёшь зонт.
Пока не наступит полночь — празднуешь.

В программировании это реализуется с помощью условий и циклов. Давай разбираться по порядку.

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

Условные операторы позволяют выполнять код только если выполняется некое условие (логическое выражение).

`if`

x := 10
if x > 5 {
    fmt.Println("x больше 5")
}

Можно добавить блок else, если нужно выполнить что-то другое в противном случае:

if x%2 == 0 {
    fmt.Println("x — чётное")
} else {
    fmt.Println("x — нечётное")
}

Допустимо объявить переменную прямо внутри if:

if y := 7; y < 10 {
    fmt.Println("y меньше 10")
}

`switch`

switch — это способ выбора из нескольких вариантов. Вместо того чтобы писать много if-else, можно использовать switch.

day := "среда"
switch day {
case "понедельник":
    fmt.Println("Начало недели")
case "пятница":
    fmt.Println("Почти выходные")
default:
    fmt.Println("Обычный день")
}

switch автоматически прерывается после первого совпадения — break писать не нужно.
Можно объединять несколько значений:

switch day {
case "суббота", "воскресенье":
    fmt.Println("Выходной!")
}

🔁 Циклы

Циклы позволяют выполнять одни и те же действия многократно. Например, вывести на экран числа от 1 до 10 или проверять ввод, пока пользователь не введёт правильное значение.

В Go есть только один цикл — for, но он умеет всё.

Стандартный `for`

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

Объяснение:

i := 0 — начальное значение
i < 5 — условие продолжения
i++ — шаг (увеличиваем i на 1)

Как `while`

x := 5
for x > 0 {
    fmt.Println(x)
    x--
}

Этот цикл работает, пока x больше нуля.

Бесконечный цикл

for {
    fmt.Println("Бесконечность")
    break // Не забудь выйти ;)
}

⏭ Управление потоком

Иногда нужно изменить поведение цикла:

break — завершает цикл или switch.
continue — пропускает текущую итерацию и переходит к следующей.

for i := 1; i <= 5; i++ {
    if i == 3 {
        continue // Пропускаем 3
    }
    fmt.Println(i)
}

Результат:

🔄 Цикл `for range` — итерация по коллекциям

for range — идиоматичный способ перебора элементов в Go. Работает с массивами, слайсами, картами, строками и каналами.

Итерация по слайсам и массивам

package main

import "fmt"

func main() {
    numbers := []int{10, 20, 30, 40}
    
    // Получаем и индекс, и значение
    for index, value := range numbers {
        fmt.Printf("Индекс %d: значение %d\n", index, value)
    }
    
    // Только значения (игнорируем индекс)
    for _, value := range numbers {
        fmt.Printf("Значение: %d\n", value)
    }
    
    // Только индексы
    for index := range numbers {
        fmt.Printf("Индекс: %d\n", index)
    }
}

Итерация по картам

students := map[string]int{
    "Алиса": 95,
    "Боб":   87,
    "Катя":  92,
}

for name, score := range students {
    fmt.Printf("%s получил %d баллов\n", name, score)
}

Итерация по строкам (rune за rune)

text := "Привет"
for index, char := range text {
    fmt.Printf("Позиция %d: символ %c\n", index, char)
}

💡 for range автоматически обрабатывает UTF-8 кодировку, поэтому корректно работает с русскими символами.

🔒 `defer` — отложенное выполнение

defer — ключевое слово, которое откладывает выполнение функции до момента завершения текущей функции. Это критически важная конструкция в Go.

Базовый синтаксис

package main

import "fmt"

func main() {
    fmt.Println("Начало")
    defer fmt.Println("Это выполнится в конце")
    fmt.Println("Середина")
    fmt.Println("Почти конец")
    // defer выполнится здесь автоматически
}

Результат:

Начало
Середина
Почти конец
Это выполнится в конце

Множественные defer (выполняются в обратном порядке)

func example() {
    defer fmt.Println("Первый defer")
    defer fmt.Println("Второй defer")
    defer fmt.Println("Третий defer")
    fmt.Println("Основной код")
}

Результат:

Основной код
Третий defer
Второй defer
Первый defer

Практическое применение — работа с ресурсами

package main

import (
    "fmt"
    "os"
)

func readFile(filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer file.Close() // ✅ Файл гарантированно закроется
    
    // Работаем с файлом...
    fmt.Println("Файл открыт и обрабатывается")
    
    // Даже если здесь произойдет ошибка,
    // file.Close() все равно выполнится
    return nil
}

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

Закрытие файлов и сетевых соединений
Освобождение блокировок (mutex unlock)
Логирование завершения операций
Очистка временных ресурсов
Восстановление после panic

⚠️ defer выполняется даже при panic, что делает его надежным механизмом очистки ресурсов.

🏷 Метки (labels) для управления циклами

Метки позволяют управлять вложенными циклами, указывая точно, какой цикл нужно прервать или продолжить.

package main

import "fmt"

func findInMatrix() {
    matrix := [][]int{
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9},
    }
    
    target := 5
    
OuterLoop: // Метка для внешнего цикла
    for i, row := range matrix {
        for j, value := range row {
            if value == target {
                fmt.Printf("Найдено %d в позиции [%d][%d]\n", target, i, j)
                break OuterLoop // Выходим из всех циклов
            }
        }
    }
}

Использование continue с метками

func skipEvenRows() {
    matrix := [][]int{{1, 2}, {3, 4}, {5, 6}}
    
RowLoop:
    for i, row := range matrix {
        if i%2 == 0 {
            continue RowLoop // Пропускаем четные строки
        }
        for _, value := range row {
            fmt.Printf("%d ", value)
        }
        fmt.Println()
    }
}

🧪 Практический пример: Обработка данных

package main

import (
    "fmt"
    "strings"
)

func processStudentData() {
    students := map[string][]int{
        "Алиса": {95, 87, 92},
        "Боб":   {78, 85, 90},
        "Катя":  {88, 91, 89},
    }
    
    fmt.Println("📊 Анализ успеваемости студентов")
    fmt.Println(strings.Repeat("=", 40))
    
    for name, grades := range students {
        defer fmt.Printf("✅ Обработка %s завершена\n", name)
        
        var total, count int
        var hasLowGrade bool
        
        fmt.Printf("\n👤 Студент: %s\n", name)
        fmt.Print("📝 Оценки: ")
        
        for i, grade := range grades {
            fmt.Printf("%d", grade)
            if i < len(grades)-1 {
                fmt.Print(", ")
            }
            
            total += grade
            count++
            
            if grade < 80 {
                hasLowGrade = true
            }
        }
        
        average := float64(total) / float64(count)
        fmt.Printf("\n📈 Средний балл: %.1f\n", average)
        
        // Определяем статус студента
        switch {
        case average >= 90:
            fmt.Println("🏆 Статус: Отличник")
        case average >= 80:
            fmt.Println("⭐ Статус: Хорошист")
        case hasLowGrade:
            fmt.Println("⚠️  Статус: Требует внимания")
        default:
            fmt.Println("📚 Статус: Удовлетворительно")
        }
    }
}

func main() {
    processStudentData()
}

💡 Идиоматичные Go паттерны

Early Return (ранний возврат)

func validateUser(user User) error {
    if user.Name == "" {
        return errors.New("имя пользователя обязательно")
    }
    
    if user.Age < 0 {
        return errors.New("возраст не может быть отрицательным")
    }
    
    if user.Email == "" {
        return errors.New("email обязателен")
    }
    
    // Основная логика только если все проверки пройдены
    return nil
}

Guard Clauses (защитные условия)

func processOrder(order *Order) error {
    // Защитные условия в начале
    if order == nil {
        return errors.New("заказ не может быть nil")
    }
    
    if len(order.Items) == 0 {
        return errors.New("заказ должен содержать товары")
    }
    
    // Основная логика обработки
    // ...
    return nil
}

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

📌 Главное из главы

Условные операторы (if, else, switch) позволяют выполнять код в зависимости от условий.
Цикл for — универсальный способ повторения кода.
for range — идиоматичный способ итерации по коллекциям в Go.
defer — критически важная конструкция для гарантированной очистки ресурсов.
Метки позволяют точно управлять вложенными циклами.
Early return и guard clauses делают код более читаемым и надежным.
Можно использовать break и continue для управления работой цикла.
Эти конструкции позволяют писать гибкие и логичные программы.

🛠 Практические упражнения

Упражнение 1: Анализ чисел

Напишите программу, которая:

Создает слайс чисел от 1 до 20
Использует for range для перебора
Выводит только четные числа
Подсчитывает сумму четных чисел
Использует defer для вывода итоговой суммы

Упражнение 2: Обработка текста

Создайте функцию, которая:

Принимает строку текста
Использует for range для перебора символов
Подсчитывает количество гласных и согласных
Игнорирует пробелы и знаки препинания
Возвращает результат в виде карты

Упражнение 3: Поиск в матрице

Реализуйте функцию поиска элемента в двумерном массиве:

Используйте вложенные циклы с метками
При нахождении элемента выходите из всех циклов
Верните координаты найденного элемента
Используйте defer для логирования времени поиска

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

if#

switch#

🔁 Циклы#

Стандартный for#

Как while#

Бесконечный цикл#

⏭ Управление потоком#

🔄 Цикл for range — итерация по коллекциям#

Итерация по слайсам и массивам#

Итерация по картам#

Итерация по строкам (rune за rune)#

🔒 defer — отложенное выполнение#

Базовый синтаксис#

Множественные defer (выполняются в обратном порядке)#

Практическое применение — работа с ресурсами#

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

🏷 Метки (labels) для управления циклами#

Использование continue с метками#

🧪 Практический пример: Обработка данных#

💡 Идиоматичные Go паттерны#

Early Return (ранний возврат)#

Guard Clauses (защитные условия)#

📌 Главное из главы#

🛠 Практические упражнения#

Упражнение 1: Анализ чисел#

Упражнение 2: Обработка текста#

Упражнение 3: Поиск в матрице#

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

`if`

`switch`

🔁 Циклы

Стандартный `for`

Как `while`

Бесконечный цикл

⏭ Управление потоком

🔄 Цикл `for range` — итерация по коллекциям

Итерация по слайсам и массивам

Итерация по картам

Итерация по строкам (rune за rune)

🔒 `defer` — отложенное выполнение

Базовый синтаксис

Множественные defer (выполняются в обратном порядке)

Практическое применение — работа с ресурсами

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

🏷 Метки (labels) для управления циклами

Использование continue с метками

🧪 Практический пример: Обработка данных

💡 Идиоматичные Go паттерны

Early Return (ранний возврат)

Guard Clauses (защитные условия)

📌 Главное из главы

🛠 Практические упражнения

Упражнение 1: Анализ чисел

Упражнение 2: Обработка текста

Упражнение 3: Поиск в матрице