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.
This program uses a simple switch
statement. It assigns the constant "id" to 10. It then switches on that value.
switch
has a case for all possible values.switch
. In Swift, a case must match all possibilities.let id = 10
switch id {
case 9:
print("Nine")
case 10:
print("Ten")
case 11:
print("Eleven")
default:
break
}Ten
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
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
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
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.
test()
method with tuple arguments. When the first item of a tuple is greater than or equal to 10, we print our values.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
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
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
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
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, errorFor 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.