Часть 2. Основы языкаУрок 08# go# основы# условия

Switch-case

switch без break, несколько значений, условия, fallthrough, type switch

Цели главы

  • Писать switch по значению с default.
  • Перечислять несколько значений в одном case.
  • Использовать switch с инициализацией и без выражения — для диапазонов.
  • Понимать fallthrough и type switch.

Когда if-else становится громоздким

Представь 10 жанров, и для каждого своя обработка: 10 веток else if подряд читать тяжело. switch проверяет значение и выполняет подходящий case; если не подошёл ни один — выполняется default.

go
package main

import "fmt"

func genreName(code int) string {
    switch code {
    case 1:
        return "Боевик"
    case 2:
        return "Комедия"
    case 3:
        return "Драма"
    default:
        return "Неизвестный жанр"
    }
}

func main() {
    fmt.Println(genreName(3))
    fmt.Println(genreName(5))
}
stdout // вывод программы
Драма
Неизвестный жанр

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

Значения перечисляют через запятую — это как «или» в if, только компактнее. Не нужно дублировать одинаковый код в разных case.

go
package main

import "fmt"

func audience(rating string) string {
    switch rating {
    case "G", "PG":
        return "для всей семьи"
    case "PG-13":
        return "с 13 лет"
    case "R", "NC-17":
        return "для взрослых"
    default:
        return "рейтинг не указан"
    }
}

func main() {
    fmt.Println(audience("PG"))
    fmt.Println(audience("PG-13"))
    fmt.Println(audience("NC-17"))
}
stdout // вывод программы
для всей семьи
с 13 лет
для взрослых

switch с инициализацией

Как и в if, переменную можно объявить прямо в switch — она будет видна только внутри него и не засорит внешнюю область видимости.

go
package main

import (
    "fmt"
    "time"
)

func main() {
    switch h := time.Now().Hour(); { // h видна только внутри switch
    case h < 12:
        fmt.Println("Доброе утро")
    case h < 18:
        fmt.Println("Добрый день")
    default:
        fmt.Println("Добрый вечер")
    }
    // недетерминированный вывод
}

Пример вывода — зависит от времени запуска:

text
Добрый день

switch без выражения — для диапазонов

Если после switch ничего не написать, каждый case содержит условие, как в if. По сути это switch true: Go ищет первый case, условие которого истинно. Для диапазонов значений это читается гораздо чище цепочки else if.

go
package main

import "fmt"

func verdict(score float64) string {
    switch {
    case score >= 9.0:
        return "шедевр"
    case score >= 7.5:
        return "хороший фильм"
    case score >= 5.0:
        return "на один раз"
    default:
        return "не стоит времени"
    }
}

func main() {
    for _, s := range []float64{9.3, 7.3, 4.1} {
        fmt.Println(s, "—", verdict(s))
    }
}
stdout // вывод программы
9.3 — шедевр
7.3 — на один раз
4.1 — не стоит времени

fallthrough

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

go
package main

import "fmt"

func main() {
    tier := 1 // 1 — максимальный тариф
    fmt.Println("Тариф", tier, "включает:")
    switch tier {
    case 1:
        fmt.Println("- 4K и Dolby Atmos")
        fallthrough
    case 2:
        fmt.Println("- просмотр без рекламы")
        fallthrough
    default:
        fmt.Println("- базовый каталог")
    }
}
stdout // вывод программы
Тариф 1 включает:
- 4K и Dolby Atmos
- просмотр без рекламы
- базовый каталог

Type switch

Особый вид switch определяет тип значения: switch v := x.(type) { case int: … }. Работает со значениями типа интерфейс — например, с пустым интерфейсом interface{} (его короткое имя any), которому подходит любой тип. Внутри каждой ветки v уже имеет тип этой ветки. Подробно интерфейсы разобраны в 16 — Интерфейсы.

go
package main

import "fmt"

func identify(v any) string {
    switch val := v.(type) {
    case int:
        return fmt.Sprintf("%d → int", val)
    case string:
        return fmt.Sprintf("%q → string", val)
    case float64:
        return fmt.Sprintf("%.1f → float64", val)
    case bool:
        return fmt.Sprintf("%t → bool", val)
    default:
        return fmt.Sprintf("%v → %T", val, val)
    }
}

func main() {
    fmt.Println(identify(42))
    fmt.Println(identify("Матрица"))
    fmt.Println(identify(9.1))
    fmt.Println(identify(true))
    fmt.Println(identify([]int{1, 2}))
}
stdout // вывод программы
42 → int
"Матрица" → string
9.1 → float64
true → bool
[1 2] → []int

Практика в уроке: кнопки плеера

Пользователь жмёт кнопки плеера — у каждого действия свой обработчик. Идеальная задача для switch.

go
package main

import "fmt"

func handleAction(action string) {
    switch action {
    case "play":
        fmt.Println("Воспроизведение")
    case "pause":
        fmt.Println("Пауза")
    default:
        fmt.Println("Нет такого действия:", action)
    }
}

func main() {
    for _, action := range []string{"play", "pause", "skip"} {
        handleAction(action)
    }
}
stdout // вывод программы
Воспроизведение
Пауза
Нет такого действия: skip

Практика

Домашнее задание: интерактивный плеер GoFlix

  1. Создай слайс команд: play, pause, stop, next, previous, volume_up, volume_down, info, like, share, quit.
  2. Перебери их в цикле и обработай каждую через switch.
  3. Объедини в один case через запятую: управление воспроизведением (play, pause, stop), переключение фильма (next, previous) и громкость (volume_up, volume_down).
  4. Незнакомые команды — в default; quit завершает обработку.
решениеЭталонное решение
go
package main

import "fmt"

func main() {
    commands := []string{
        "play", "pause", "stop", "next", "previous",
        "volume_up", "volume_up", "volume_down",
        "info", "like", "share", "rewind", "quit", "play",
    }

    volume := 50
player:
    for _, cmd := range commands {
        switch cmd {
        case "play", "pause", "stop":
            fmt.Println("Воспроизведение:", cmd)
        case "next", "previous":
            fmt.Println("Переключение фильма:", cmd)
        case "volume_up", "volume_down":
            if cmd == "volume_up" {
                volume += 10
            } else {
                volume -= 10
            }
            fmt.Println("Громкость:", volume)
        case "info":
            fmt.Println("Интерстеллар, 2014, 169 мин")
        case "like":
            fmt.Println("Добавлено в избранное")
        case "share":
            fmt.Println("Ссылка скопирована")
        case "quit":
            fmt.Println("Выход из плеера")
            break player
        default:
            fmt.Println("Неизвестная команда:", cmd)
        }
    }
}
stdout // вывод программы
Воспроизведение: play
Воспроизведение: pause
Воспроизведение: stop
Переключение фильма: next
Переключение фильма: previous
Громкость: 60
Громкость: 70
Громкость: 60
Интерстеллар, 2014, 169 мин
Добавлено в избранное
Ссылка скопирована
Неизвестная команда: rewind
Выход из плеера

Тренировка: предскажи вывод

go
package main

import "fmt"

func main() {
    x := 5
    switch {
    case x > 3:
        fmt.Println("больше 3")
        fallthrough
    case x > 10:
        fmt.Println("больше 10")
    case x > 1:
        fmt.Println("больше 1")
    }
}
самопроверкаОтвет
text
больше 3
больше 10

fallthrough выполняет тело следующего case, не проверяя x > 10. Дальше провала нет: после второй ветки switch завершается, и «больше 1» не печатается.

Проверь себя

вопросНужен ли break в конце case в Go?

Нет. После выполнения ветки Go сам выходит из switch, провала в следующий case нет.

вопросКак обработать несколько значений одним case?

Перечислить их через запятую: case "G", "PG":.

вопросКак с помощью switch проверить диапазоны значений?

Написать switch без выражения и условия в case: case score >= 9: — выполняется первый истинный.

вопросЧто делает fallthrough?

Безусловно выполняет тело следующего case, не проверяя его условие.

вопросКак узнать конкретный тип значения в переменной типа any?

Через type switch: switch v := x.(type) { case int: … case string: … }.

вопросПочему break внутри switch не останавливает окружающий цикл?

В Go break относится к ближайшему switch, select или for. Внутри switch он выходит из switch; для цикла нужна метка: break loop.


Ключевые выводы

  • 🔀 switch заменяет длинные цепочки else if и читается проще.
  • 🚫 break в case не нужен — провала по умолчанию нет.
  • 📋 Несколько значений в одном case — через запятую.
  • 📏 switch без выражения удобен для диапазонов; с инициализацией — не засоряет область видимости.
  • ⬇️ fallthrough безусловно проваливается в следующий case — используй редко.
  • 🧬 Type switch выбирает ветку по типу значения в интерфейсе.
// связанные темы и шпаргалки