Конспект 3 Golang (Go) : Циклы - Switch

В языке Go есть только один вид цикла - это цикл (for). В нём нет привычных для других языков операторов (while) или (do-while), но он с легкостью заменяет их все.

Классический цикл со счетчиком используется, когда код нужно повторить фиксированное кол-во раз. В круглых скобках () условие не требуется.

package main import "fmt" func main() { for i := 0; i < 5; i++ { fmt.Println(i) // цикл начнется с 0 и закончится 4 } }

i := 0 - Начальное значение
i<5 - Условие (цикл работает пока оно верно)
i++ - Шаг (увеличение счетчика на 1)
fmt.Println(i) - Выводит текущее значение i

Если оставить только условие, то цикл будет работать, пока оно не станет false.

package main import "fmt" func main() { count := 1 for count <= 3 { fmt.Println("Считаем:", count) count++ // Если забыть изменить переменную, цикл станет бесконечным } }

count := 1 - Начальное значение переменной count
count <= 3 - Условие (цикл выполняется, пока count меньше или равен 3)
fmt.Println("Считаем:", count) - Выводит текущее значение count
count++ - Увеличивает count на 1 после каждой итерации

Используется, например, в серверах, которые должны работать постоянно.

package main import "fmt" func main() { for { // Код будет выполняться вечно // Чтобы выйти, внутри должно быть условие с командой break } }

4. Цикл (for range) для перебора коллекций (это те самые массивы, срезы и карты)

Самый частый сценарий в Go - обход массивов (arraus), срезов (slices), строк или карт (maps).

package main import "fmt" func main() { letters := []string{"a", "b", "c"} for index, value := range letters { fmt.Println(index, value) } }

letters := []string{"a", "b", "c"} - Создаётся срез строк с тремя элементами
range letters - Последовательно перебирает все элементы среза
index - Получает индекс текущего элемента (0, 1, 2)
value - Получает значение текущего элемента ("a", "b", "c")
fmt.Println(index, value) - Выводит индекс и значение элемента

Если индекс не нужен, его можно заменить на пустой идентификатор (нижнее подчеркивание):

package main import "fmt" func main() { letters := []string{"a", "b", "c"} for _, value := range letters { fmt.Println(value) } }

В Go есть несколько операторов для управления циклом

break - Полностью завершает цикл.
continue - Пропускает текущую итерацию.
return - Завершает функцию вместе с циклом.

Примеры:

package main import "fmt" func main() { for i := 1; i <= 5; i++ { if i == 3 { break } fmt.Println(i) } }

i == 3 - условие выхода из цикла
break - немедленно завершает цикл при выполнении условия

Результат:

Результат без break и условия:

package main import "fmt" func main() { for i := 1; i <= 5; i++ { if i == 3 { continue } fmt.Println(i) } }

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

Результат:

Результат без continue:

func main() { for i := 1; i <= 5; i++ { if i == 3 { return } fmt.Println(i) } fmt.Println("Этот код не выполнится") }

return завершает и цикл и всю функцию main.

Результат:

Результат без return:

Конструкция switch в Go - это более удобная и читаемая замена множественным проверкам через if-else.

Главная особенность Go заключается в том, что после выполнения совпавшего case оператор switch автоматически завершается. Поэтому обычно не нужно писать break в конце каждого блока.

switch - начинает проверку.
case - возможный вариант значения.
default - запасной вариант, если ничего не подошло.

Проверяет конкретную переменную на совпадение с разными значениями.

package main import "fmt" func main() { color := "green" switch color { case "red": fmt.Println("Стоп!") case "yellow": fmt.Println("Внимание!") case "green": fmt.Println("Иди!") // Сработает эта ветка default: fmt.Println("Светофор сломался") // Если ни одно условие не подошло } }

switch color - Go начинает сравнивать значение переменной color с каждым case.
case "red" - Выполнится, если color равно "red".
case "yellow" - Выполнится, если color равно "yellow".
case "green" - Выполнится, если color равно "green".
default - Выполнится, если ни один case не подошёл.

Принцип тот же, но с несколькими вариантами через запятую, если для них нужен один и тот же код.

package main import "fmt" func main() { day := "Суббота" switch day { case "Понедельник", "Вторник", "Среда", "Четверг", "Пятница": fmt.Println("Это рабочий день.") case "Суббота", "Воскресенье": fmt.Println("Можно и в бар") // Сработает эта ветка } }

Если не указывать переменную после слова switch, конструкция будет вести себя как цепочка if-else. В case можно писать любые логические условия.

package main import "fmt" func main() { age := 15 switch { case age < 18: fmt.Println("челепиздрик") // срабоает эта ветка, так как 15 меньше 18 case age >= 18 && age < 65: fmt.Println("то что надо") default: fmt.Println("старпёр") } }

Используется, чтобы после выполнения текущего case программа провалилась в следующий, даже если его условие неверно.

number := 10 switch number { case 10: fmt.Println("Число равно 10") fallthrough case 20: fmt.Println("Этот код тоже выполнится из-за fallthrough") }

Тут стоит объяснить

fallthrough принудительно передаёт выполнение следующему case, не проверяя его условие.

пока так)

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

Конспект 3 Golang (Go) : Циклы - Switch

8. Цикл и его интерпретации

1. Классический цикл

2. Аналог цикла (While) (пока условие истинно)

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

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

break - выйти из цикла при выполнении условия

continue - Пропускает итерацию

return - Завершает функцию вместе с циклом

9. Конструкция Switch

1. Классический Switch

2. Несколько значений в одном case

3. switch без выражения (вместо длинных if-else)

4. Ключевое слово fallthrough