Как сделать так, чтобы switch обработал следующий case, даже если текущий уже обработан?

Обработка нескольких case в Swift switch

В Swift оператор switch по умолчанию работает по принципу "пройти через" (no implicit fallthrough) — после выполнения подходящего case управление передается за пределы всего оператора switch, и следующие case не проверяются. Это фундаментальное отличие от C/Objective-C, где требуется явный break.

Явное указание прохода через case (fallthrough)

Для обработки следующего case после текущего используется ключевое слово fallthrough. Оно принудительно передает управление в следующий case (или default), не проверяя его условие. Это прямое решение вашего вопроса.

let number = 5

switch number {
case 5:
    print("Число равно 5")
    fallthrough // Переход к следующему case без проверки
case 6:
    print("Этот блок тоже выполнится, даже если number != 6")
    fallthrough // Можно идти дальше
case 7:
    print("И этот тоже")
default:
    print("Завершающий блок")
}

Вывод:

Число равно 5
Этот блок тоже выполнится, даже если number != 6
И этот тоже

Важные особенности fallthrough

1. Нет проверки условия: Код следующего case выполняется автоматически, даже если его условие ложно.
2. Не происходит возврата: После fallthrough нельзя вернуться в предыдущий case.
3. Логика может быть неочевидной: Использование требует внимания, так как нарушает стандартную "защиту от промахов" Swift.

Альтернативные подходы (часто более предпочтительные)

Использование fallthrough — прямое, но не всегда самое чистое решение. Часто логику "выполнить для нескольких условий" лучше выразить иначе.

1. Перечисление нескольких значений в одном case (через запятую)

Идеально, когда несколько входных значений должны запускать одинаковый код.

let character: Character = "z"

switch character {
case "a", "e", "i", "o", "u": // Один блок для всех гласных
    print("Гласная буква")
case "b", "c", "d", "z": // Один блок для этой группы согласных
    print("Согласная буква из определенной группы")
default:
    print("Другой символ")
}

2. Использование where для составных условий

Позволяет создать сложные условия для входа в case.

let point = (x: 1, y: 10)

switch point {
case let (x, y) where x == y:
    print("Точка на линии y = x")
case let (x, y) where y == x * x:
    print("Точка на параболе y = x^2")
    // Здесь можно выполнить общую логику для точек на кривых
case (_, _):
    print("Произвольная точка")
}

3. Вынос общей логики в отдельные функции

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

func processCommonStepA() {
    print("Выполняем общий шаг A")
}

func processCommonStepB() {
    print("Выполняем общий шаг B")
}

let code = 200

switch code {
case 200:
    processCommonStepA()
    processCommonStepB()
    print("Успех! OK")
case 404:
    processCommonStepA() // Только общий шаг A
    print("Ошибка: Не найдено")
default:
    print("Другой статус")
}

Когда действительно нужен fallthrough?

fallthrough уместен в относительно редких сценариях, часто при портировании кода из C или для реализации специфичных конечных автоматов, где следующий case логически является "продолжением" предыдущего.

// Пример: Консольный парсер с накоплением состояния
var output = ""
let tokens = ["DEBUG:", "Ошибка", "в", "модуле", "X"]

for token in tokens {
    switch token {
    case "DEBUG:", "WARNING:", "ERROR:":
        output += "[\(token)] " // Добавляем префикс
        fallthrough // И хотим также обработать токен как обычное слово
    default:
        output += token + " " // Добавляем само слово
    }
}
print(output) // [DEBUG:] Ошибка в модуле X

Итог

• Для явного перехода к следующему case используйте fallthrough.
• Помните, что fallthrough игнорирует условие следующего case.
• В большинстве ситуаций лучше использовать альтернативы: перечисление значений, составные условия where или вынос общей логики. Это делает код безопаснее, понятнее и легче для модификации.
• Swift намеренно отказался от неявного "проваливания", чтобы предотвратить целый класс ошибок, common в C-подобных языках. Поэтому используйте fallthrough осознанно.