Условия и циклы в Go

Введение: Почему важно управлять потоком?

Представь, что ты — дирижёр оркестра. Музыканты (твой код) знают свои партии, но кто-то должен решать, когда играть скрипкам, когда — трубам, а когда всем вместе. В программировании эту роль выполняет управление потоком — набор инструкций, которые говорят программе, что делать в разных ситуациях.

В прошлых уроках мы писали программы, которые выполнялись строка за строкой. Но в реальной жизни так не бывает! Иногда нужно принять решение («если дождь — возьми зонт»), повторить действие («сделай 10 отжиманий») или выбрать один из нескольких вариантов. В этом уроке мы научимся всему этому на языке Go.

💡 Запомни: Управление потоком — это как дорожные знаки для твоей программы. Без них код будет ехать прямо, не сворачивая, даже если впереди пропасть!

Условные операторы: if, else if, else

Оператор if — первое решение

Самый простой способ принять решение в Go — использовать оператор if. Он проверяет условие и выполняет код, только если условие истинно.

package main

import "fmt"

func main() {
    возраст := 14
    
    // Проверяем, можно ли смотреть фильм с рейтингом 16+
    if возраст >= 16 {
        fmt.Println("Можно смотреть фильм!")
    }
    
    fmt.Println("Программа завершена")
}

В этом примере, если переменная возраст меньше 16, сообщение не появится. Попробуй изменить значение на 16 или больше — и ты увидишь приветствие!

Как это работает? Go вычисляет условие в скобках. Если оно даёт true (истина), выполняется код внутри фигурных скобок. Если false (ложь) — Go просто идёт дальше.

Аналогия из жизни

Представь, что ты подходишь к турникету в метро. Если у тебя есть билет (условие истинно), турникет открывается. Если билета нет — ты проходишь мимо, и турникет остаётся закрытым. Оператор if работает точно так же!

Добавляем else — второй путь

Часто нужно сделать одно, если условие верно, и другое — если нет. Для этого используем else.

package main

import "fmt"

func main() {
    температура := 25
    
    if температура > 20 {
        fmt.Println("На улице тепло, идём гулять!")
    } else {
        fmt.Println("Холодно, сидим дома с чаем.")
    }
}

Теперь программа всегда выводит одно из двух сообщений. Если температура больше 20 — первое, иначе — второе.

Цепочка решений: else if

А что если вариантов больше двух? Например, нужно оценить оценку ученика: 5 — отлично, 4 — хорошо, 3 — удовлетворительно, 2 — плохо. Для этого используем else if.

package main

import "fmt"

func main() {
    оценка := 4
    
    if оценка == 5 {
        fmt.Println("Отлично! Молодец!")
    } else if оценка == 4 {
        fmt.Println("Хорошо, но можно лучше!")
    } else if оценка == 3 {
        fmt.Println("Удовлетворительно, старайся!")
    } else if оценка == 2 {
        fmt.Println("Плохо, нужно подтянуть знания!")
    } else {
        fmt.Println("Такой оценки не бывает!")
    }
}

Go проверяет условия по порядку. Как только находит истинное — выполняет соответствующий блок кода и выходит из всей конструкции. Если ни одно условие не подошло, выполняется блок else (если он есть).

Логические операторы: И, ИЛИ, НЕ

Иногда нужно проверить несколько условий одновременно. Например, «если сегодня суббота ИЛИ воскресенье, то выходной». Для этого в Go есть логические операторы:

• && — логическое И (оба условия должны быть истинны)
• || — логическое ИЛИ (хотя бы одно условие истинно)
• ! — логическое НЕ (меняет true на false и наоборот)

package main

import "fmt"

func main() {
    деньНедели := "Суббота"
    естьДомашка := false
    
    // Проверяем: если выходной И нет домашки — гуляем
    if (деньНедели == "Суббота" || деньНедели == "Воскресенье") && !естьДомашка {
        fmt.Println("Ура! Можно гулять весь день!")
    } else if деньНедели == "Суббота" || деньНедели == "Воскресенье" {
        fmt.Println("Выходной, но нужно сделать домашку :(")
    } else {
        fmt.Println("Будний день, пора в школу!")
    }
}

Важно: Обрати внимание на скобки! Они помогают Go понять, какое условие проверять в первую очередь. Без скобок результат может быть неожиданным.

Таблица истинности для логических операторов

A	B	A && B	A || B	!A
true	true	true	true	false
true	false	false	true	false
false	true	false	true	true
false	false	false	false	true

Циклы: повторение — мать учения

Циклы позволяют выполнять один и тот же блок кода много раз. Это как если бы ты повторял упражнение на уроке физкультуры 10 раз, но вместо тебя это делал бы робот.

Цикл for — самый главный

В Go есть только один вид цикла — for. Но он умеет делать всё, что нужно! Рассмотрим три способа его использования.

1. Классический for (как в других языках)

package main

import "fmt"

func main() {
    // Выводим числа от 1 до 5
    for i := 1; i <= 5; i++ {
        fmt.Println("Счёт:", i)
    }
}

Здесь три части:

• Инициализация: i := 1 — создаём счётчик и задаём начальное значение.
• Условие: i <= 5 — пока условие истинно, цикл продолжается.
• Обновление: i++ — увеличиваем счётчик на 1 после каждой итерации.

Попробуй изменить условие на i <= 10 — и программа выведет числа от 1 до 10!

2. For как while

Если нужно повторять что-то, пока условие истинно, можно опустить инициализацию и обновление.

package main

import "fmt"

func main() {
    энергия := 100
    
    // Бежим, пока есть энергия
    for энергия > 0 {
        fmt.Println("Бегу! Осталось энергии:", энергия)
        энергия -= 10 // тратим 10 единиц энергии за шаг
    }
    
    fmt.Println("Устал, нужно отдохнуть!")
}

Этот цикл будет работать, пока энергия больше 0. На каждом шаге мы уменьшаем её на 10. Когда энергия станет 0 или меньше, цикл завершится.

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

Если не написать условие, цикл будет выполняться вечно. Используй это осторожно!

package main

import "fmt"

func main() {
    счётчик := 0
    
    for {
        счётчик++
        fmt.Println("Проход номер:", счётчик)
        
        // Обязательно нужно условие выхода, иначе программа зависнет!
        if счётчик >= 5 {
            break // break прерывает цикл
        }
    }
}

Важно: Всегда предусматривай способ выхода из цикла! Иначе программа будет работать бесконечно и может зависнуть компьютер.

Операторы break и continue

• break — немедленно завершает цикл.
• continue — пропускает оставшуюся часть текущей итерации и переходит к следующей.

package main

import "fmt"

func main() {
    // Выводим только чётные числа от 1 до 10
    for i := 1; i <= 10; i++ {
        if i % 2 != 0 { // если число нечётное
            continue // пропускаем эту итерацию
        }
        fmt.Println("Чётное число:", i)
    }
    
    // Останавливаемся, когда находим число 7
    for j := 1; j <= 10; j++ {
        if j == 7 {
            fmt.Println("Нашли число 7, останавливаемся!")
            break
        }
        fmt.Println("Ищем 7... текущее число:", j)
    }
}

Аналогия из жизни

Представь, что ты моешь посуду. Цикл for — это когда ты моешь тарелки одну за другой, пока они не закончатся. break — это если пришла мама и сказала: «Хватит, иди гулять!» — ты бросаешь мытьё. continue — это если ты пропускаешь грязную тарелку (потому что её нужно замочить) и переходишь к следующей.

Вложенные конструкции: if внутри for и наоборот

Управление потоком можно комбинировать. Например, можно использовать if внутри цикла или цикл внутри if. Это называется вложенными конструкциями.

package main

import "fmt"

func main() {
    // Таблица умножения для числа 5
    число := 5
    
    fmt.Println("Таблица умножения для", число)
    for i := 1; i <= 10; i++ {
        результат := число * i
        // Особое сообщение для чётных результатов
        if результат % 2 == 0 {
            fmt.Printf("%d × %d = %d (чётное)\n", число, i, результат)
        } else {
            fmt.Printf("%d × %d = %d (нечётное)\n", число, i, результат)
        }
    }
}

Здесь цикл for перебирает множители от 1 до 10, а внутри каждой итерации if проверяет, чётный ли результат.

Switch — элегантная замена длинным else if

Когда нужно проверить множество вариантов для одной переменной, switch делает код чище и понятнее.

package main

import "fmt"

func main() {
    день := "Понедельник"
    
    switch день {
    case "Понедельник":
        fmt.Println("Начало недели, пора в школу!")
    case "Вторник", "Среда", "Четверг":
        fmt.Println("Обычный учебный день.")
    case "Пятница":
        fmt.Println("Последний учебный день, ура!")
    case "Суббота", "Воскресенье":
        fmt.Println("Выходной! Можно отдыхать!")
    default:
        fmt.Println("Такого дня недели не существует!")
    }
}

Как это работает: Go сравнивает значение переменной день с каждым case по порядку. Как только находит совпадение — выполняет соответствующий код. default выполняется, если ни один case не подошёл.

Обрати внимание: в Go не нужно писать break после каждого case — он вставляется автоматически! Это удобно и предотвращает ошибки.

Switch без выражения

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

package main

import "fmt"

func main() {
    возраст := 16
    
    switch {
    case возраст < 7:
        fmt.Println("Ты дошкольник.")
    case возраст < 12:
        fmt.Println("Ты учишься в начальной школе.")
    case возраст < 15:
        fmt.Println("Ты в средней школе.")
    case возраст < 18:
        fmt.Println("Ты в старшей школе.")
    default:
        fmt.Println("Ты уже взрослый!")
    }
}

Практические задания

Теперь твоя очередь! Попробуй решить эти задачи самостоятельно. Если что-то не получается — перечитай урок или попроси помощи у преподавателя.

Задание 1: Калькулятор оценок

Напиши программу, которая запрашивает у пользователя число от 1 до 100 (баллы за тест) и выводит оценку:

• 90-100: "Отлично! Ты гений!"
• 75-89: "Хорошо, но можно лучше!"
• 50-74: "Удовлетворительно, подтяни!"
• 0-49: "Плохо, нужно учить!"
• Если число вне диапазона 0-100: "Некорректный ввод!"

Подсказка: Используй if, else if и else. Для ввода данных используй fmt.Scan(&переменная).

Задание 2: Таблица умножения

Напиши программу, которая выводит таблицу умножения для всех чисел от 1 до 5. Используй вложенные циклы for. Результат должен выглядеть так:

1 × 1 = 1
1 × 2 = 2
...
5 × 10 = 50

Подсказка: Один цикл будет перебирать числа от 1 до 5, а второй — множители от 1 до 10.

Задание 3: Угадай число

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

1. Загадывает случайное число от 1 до 20 (используй rand.Intn(20) + 1, не забудь импортировать "math/rand" и "time" для инициализации генератора).
2. Даёт пользователю 5 попыток угадать число.
3. После каждой попытки говорит: "Больше", "Меньше" или "Угадал!".
4. Если попытки закончились — выводит загаданное число.

Подсказка: Используй цикл for с счётчиком попыток и if для сравнения чисел. Для выхода при угадывании используй break.

🎯 Совет: Начни с простого — сначала напиши программу, которая просто выводит что-то. Потом добавляй условия по одному. И не бойся ошибок — это нормально! Каждая ошибка делает тебя лучше как программиста.

Заключение

Сегодня мы научились управлять потоком программы с помощью условных операторов (if, else if, else, switch) и циклов (for). Теперь твои программы могут принимать решения и повторять действия — как настоящие роботы!

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

Ключевые понятия урока:

• if/else — принятие решений
• Логические операторы (&&, ||, !) — комбинирование условий
• for — повторение действий
• break/continue — управление циклом
• switch — множественный выбор

Удачи в программировании! 🚀