Switch

In a Swift program with a switch statement, we test for all possible values. A switch must have a case for all possibilities.

With the case keyword, we match a value or an interval. A let statement can introduce a temporary constant. With "where," we add checks.

A simple example

This program uses a simple switch statement. It assigns the constant "id" to 10. It then switches on that value.

let id = 10

switch id {
    case 9:
        print("Nine")
    case 10:
        print("Ten")
    case 11:
        print("Eleven")
    default:
        break
}
Ten

Multiple case values

Sometimes a case should match multiple values. We cannot "stack" cases. Instead we must specify all possible values in one case.

let size = 3

// Switch on the size Int.
switch size {
    case 0, 1:
        // Two values match Small.
        print("Small")
    case 2, 3:
        // Two values match Medium.
        print("Medium")
    case 4, 5:
        // Two values match Large.
        print("Large")
    default:
        break
}
Medium

Ranges

A range is specified with a start, end and three periods in between. Ranges can be used in switch statements. All included values are matched by the range case.

let code = 70

// Switch based on ranges.
switch code {
    case 0...50:
        print("Lower half")
    case 51...100:
        print("Upper half")
    default:
        print("Invalid")
}
Upper half

Fallthrough

This keyword means that control proceeds to the next case in a switch. The next case is entered (even if the value does not match).

let size = 2
// Use switch with fallthrough statements.
switch size {
    case 3:
        // This case will execute statements in case 2, 1 and 0.
        print("Number contains 3")
        fallthrough
    case 2:
        print("Number contains 2")
        fallthrough
    case 1:
        print("Number contains 1")
        fallthrough
    case 0:
        print("Number contains 0")
    default:
        print("Invalid")
}
Number contains 2
Number contains 1
Number contains 0

String

In Swift we can use a string as the value being switched upon. We can use literals (like "cat") to match our string. The contents of the strings are compared.

let name = "cat"

// Switch on the name string.
switch name {
    case "bird":
        print("Is bird")
    case "dog":
        print("Is dog")
    case "cat":
        print("Is cat") // This is printed.
    default:
        print("Something else")
}
Is cat

Where

Sometimes we want further checking in a case. For example, we might want to check two variables (both parts of a tuple) at once. We use "where" for this.

func test(code: (Int, Character)) {
    // Switch on the tuple argument.
    // ... We use let to allow the tuple items to be referenced.
    //     We use where to test a part of the tuple.
    switch code {
        case let(number, letter) where number >= 10:
            print("Number = \(number), Letter = \(letter)")
        default:
            print("Default")
        }
}

// Call test with a tuple argument.
test(code: (5, "a"))
// Call test again.
test(code: (15, "b"))
Default
Number = 15, Letter = b

Tuple

Here we switch on a tuple. We use a "tuple pattern" to match all items in the tuple. Many syntax features, like "let" and underscores, can be used to match parts of tuples.

let data = ("xyz", 200)

// Match complete tuple values.
switch (data) {
    case ("abc", 300): print("Is abc300")
    case ("xyz", 200): print("Is xyz200")
    default: print("Not known")
}
Is xyz200

Let values

A case block can capture values in a tuple switch. We use the "let" keyword and provide an identifier (like "size" in this example).

let value = ("monkey", 200)

// Use let to capture a variable in a tuple.
switch (value) {
    case ("monkey", let size): print("Monkey has size \(size)")
    default: break
}
Monkey has size 200

Tuples, any value

With an underscore, we can match just parts of a tuple in a switch. We specify the underscore to "ignore" items in a tuple case.

let tuple = ("cat", 1, "penguin")

// Switch on tuple.
// ... Match second value of the tuple.
switch (tuple) {
    case (_, 1, _): print("Second value is 1")
    case (_, 2, _): print("Second value is 2")
    default: print("No case")
}
Second value is 1

Exhaustive, error

A switch cannot just match some cases. It must match all possible cases. The default block is useful for handling rare or unusual (unexpected) cases.

let height = 70

// This program will not work.
// ... A switch must have a default clause.
switch (height) {
    case 60: print(true)
    case 70: print(true)
}
/main.swift:8:1:
Switch must be exhaustive, consider adding a default clause

At least one case, error

A switch cannot be empty. It must have at least one case or a default block. The Swift compiler will report an error on an empty switch.

let x = 5

// A switch cannot be empty.
switch (x) {
}
/main.swift:5:1:
'switch' statement body must have at least one 'case' or 'default' block

Tuple pattern, error

For tuple patterns in a switch, each case must have the correct count of items. We cannot match a 2-item tuple with a 3-item tuple pattern case.

let result = (10, 20)

// For a tuple switch, the pattern must be correct.
switch (result) {
    case (10, 20, 30): print("OK")
}
/main.swift:3:6:
Tuple pattern has the wrong length for tuple type '(Int, Int)'

Switch is a powerful construct in Swift. It has unique features in this language. They are designed to make flow easier to design and control.