Swift - Switch Statement

In Swift, a switch statement is a type of control mechanism that permits a program to change its flow of control and take some decisions on the basis of some conditions imposed on the value of a variable. The control flow of a program comes out of the switch statement block as soon as the matching condition is met. It also provides a default condition if none of the mentioned conditions are met. Default statement inside a switch statement is optional provided that switch statement is exhaustive. In simple words, we can skip the default statement only if the switch statement already covers all possible cases to handle the value of the variable. If the switch statement doesn't cover all possible cases and at the same time the default statement is skipped, then the Swift compiler throws a compile-time error. Using switch statements in a program is a good practice and should be used whenever required. 

Syntax:

var myVariable = value

switch myVariable {

             case condition 1:

             expression 1

             fallthrough                   // Optional

             case condition 2:

             expression 2

             fallthrough                   // Optional

             ........................

             ........................

             ........................

             default:                      // Optional if switch block is exhaustive

             expression

}

Flow chart:

Why switch statements?

Switch statements are equivalent to a bunch of if-else statements. In simple words, We can achieve the same task with the help of a bunch of if-else statements as done by the switch statement. But switch statements are more efficient as compared to if-else statements as they improve the readability of the code.

For example,

Let us consider a scenario where we want to print a string according to a marked string corresponding to a character,

• "A" -> "Apple"
• "B" -> "Boy"
• "C" -> "Cat"
• "D" -> "Dog"

We can accomplish this task with the help of a switch statement as shown below:

// Swift program to illustrate the 
// working of switch statement

// Initializing a character
var myCharacter = "B"

// Switch block 
switch myCharacter 
{
    
    // If myCharacter is equal to "A"
    case "A":
    
        // Then print "Apple"
        print("Apple")
    
    // If myCharacter is equal to "B"
    case "B":
    
        // Then print "Apple"  
        print("Boy")
    
    // If myCharacter is equal to "C"  
    case "C":
    
        // Then print "Cat" 
        print("Cat")
    
    // If myCharacter is equal to "D"   
    case "D":
    
        // Then print "Dog"   
        print("Dog")
    
    // Default statement
    default:
        print("Invalid")
}

Output:

Boy

Fallthrough Statement 

A fallthrough statement allows the flow of control of a program to pass down to the next case. The body of the next case will be executed no matter whether it matches the value of the variable.  Now if the next case also contains a fallthrough statement, the flow of control of the program passes down to next of the next case and so on. Otherwise, if it doesn't contain a fallthrough statement, the flow of control of the program comes out of the switch statement immediately. 

Syntax:

var myVariable = value

switch myVariable 

{

             case condition 1:

             expression 1

             fallthrough                   

             case condition 2:

             expression 2

}

Example:

// Swift program to illustrate the working 
// of fallthrough statement in switch statement

// Initializing a character
var myCharacter = "B"

// Switch block 
switch myCharacter
{
    
    // If myCharacter is equal to "A"
    case "A":
    
        // Then print "Apple"
        print("Apple")
    
    // If myCharacter is equal to "B"
    case "B":
    
        // Then print "Apple"  
        print("Boy")
    
    // Using fallthrough so that
    // below case also gets executed
    fallthrough
    
    // If myCharacter is equal to "C"  
    case "C":
    
        // Then print "Cat" 
        print("Cat")
    
    // If myCharacter is equal to "D"   
    case "D":
    
        // Then print "Dog"   
        print("Dog")
    
    // Default statement
    default:
        print("Invalid")
}

Output:

Boy
Cat

Explanation: As myCharacter is equal to "B" so the body of the second case got executed. Since, we have used the fallthrough statement just after the body of the second case, so the body of the third case will be executed also. Note that although it doesn't satisfy the third condition  (clearly, "B" is equal to "C"), the third case is getting executed. This shows that how powerful are fallthrough statements in Swift. 

No implicit fallthrough

In a switch statement, if a case condition doesn't contain a body, the Swift compiler produces a compile-time error. This is because Swift doesn't provide an implicit fallthrough statement to deal with such case conditions. 

Example:

// Swift program to illustrate 
// No implicit fallthrough

// Initializing a character
var myCharacter = "B"

// Switch block 
switch myCharacter 
{
    
    // If myCharacter is equal to "A"
    case "A":
    
        // Then print "Apple"
        print("Apple")
    
    // If myCharacter is equal to "B"
    case "B":
    
    // No body
    
    // If myCharacter is equal to "C"  
    case "C":
    
        // Then print "Cat" 
        print("Cat")
    
    // If myCharacter is equal to "D"   
    case "D":
    
        // Then print "Dog"   
        print("Dog")
    
    // Default statement
    default:
        print("Invalid")
}

Output:

main.swift:18:5: error: 'case' label in a 'switch' should have at least one executable statement
    case "B":
    ^~~~~~~~~
              break

Explanation: In the above program, myCharacter is equal to "B". Although, we have a case condition to handle this case, it doesn't contain any executable statement in the body. 

Interval matching

Swift provides a functionality using which we can use interval matching as a case condition in a switch statement.

Syntax:

case myValue1..<myValue2:
// body of case

If the value of the variable expression lies between myValue1 and myValue2 inclusive then the body of the above case would be executed.

Example:

// Swift program to illustrate the interval 
// matching in the switch statement

// Initializing an integer
var myInteger = 18

// Switch block 
switch myInteger 
{
    
    // If myInteger is equal to 2
    case 2:
    
        // Then print "Apple"
        print("Equal to 2")
    
    // If myInteger is between 3 and 5
    case 3..<5:
    
        // Then print "Between 3 and 5"  
        print("Between 3 and 5")
    
    // If myInteger is between 6 and 10  
    case 6..<10:
    
        // Then print "Between 6 and 10"  
        print("Between 6 and 10")
    
    // If myInteger is between 11 and 22
    case 11..<22:
    
        // Then print "Between 11 and 22"  
        print("Between 11 and 22")
    
    // Default statement
    default:
        print("Invalid")
}

Output:

Between 11 and 22

Tuple matching

In Swift, a tuple is used to hold or group a number of elements together. The elements in a tuple can be of the same type as well as the different types. We can initialize a tuple in Swift by using the following syntax.

Syntax:

var myTuple = (myElement1, myElement2, . . . .)

Swift provides us a functionality using which we can use a tuple as a variable expression as well as a case condition in a switch statement to test multiple values. Every item of the tuple is checked against a different value. Or we can use underscore character (_) to match the possible value. Here the underscore character is known as the wildcard pattern.

case (value1, value2,. . . .):
// Body of case
case(_, value1):
// Body of case

Example:

// Swift program to illustrate the working
// of tuples with switch statement

// Initializing a tuple
var myTuple = (4, 10)

// Switch block 
switch myTuple 
{

    // If myTuple is equal to (2,3)
    case (2, 3):
    
        // Then print
        print("First case gets executed")
    
    // If myTuple is (between 1 and 3,between 5 and 11) 
    case (1...3, 5...11):
    
        // Then print  
        print("Second case gets executed")
    
    // If myTuple is (between 1 and 5, between 8 and 13)   
    case (1...5, 8...13):
    
        // Then print  
        print("Third case gets executed")
        
    // If myTuple is (between 11 and 13, between 15 and 18) 
    case (11...13, 15...18):
    
        // Then print  
        print("Fourth case gets executed")
    
    // Default statement
    default:
        print("Invalid")
}

Output:

Third case gets executed

Value Binding

Swift allows us to initialize a temporary variable in a case condition in switch statements, this variable is only accessible in the body of the case in which it is initialized. This property is known as value binding.

Syntax

case (let myElement1, let myElement2,..., let myElementN value1, value2, ...., valueN):
     // body

Now if all the constant values of the case condition are matched with the values of the variable expression then the rest of the values are automatically assigned to the corresponding temporary variables and the body of the case will be executed.

Example:

// Swift program to illustrate the working 
// of value binding with switch statement

// Initializing a tuple
var myTuple = (2, 4, 6)

// Switch block 
switch myTuple 
{

    // If myTuple is equal to (2,3)
    case (let myElement1, 3, 6):
    
        // Then print
        print("myElement1 is equal to \(myElement1)")
    
    // If myTuple is (between 1 and 3, between 5 and 11) 
    case (let myElement1, let myElement2, 6):
    
        // Then print
        print("myElement1 is equal to \(myElement1)", 
              "myElement3 is equal to \(myElement2)")
    
    // If myTuple is (between 1 and 5, between 8 and 13)   
    case (let myElement1, let myElement2, let myElement3):
    
        // Then print
        print("myElement1 is equal to \(myElement1)", 
              "myElement1 is equal to \(myElement2)", 
              "myElement1 is equal to \(myElement3)")
    
}

Output:

myElement1 is equal to 2 myElement3 is equal to 4

Explanation: In the above program, as myTuple is equal to (2, 4, 6). For the first case condition, as the second value of the tuple is not equal to the second value of myTuple, so the body of this case doesn't get executed. For the second case condition, as the third element of the tuple is equal to the third value of myTuple, so the values of the first and second element automatically bind with the first and second elements of the case condition.

Using where clause with a switch statement

Swift also accepts where clause in case condition in a switch statement using which we can execute statements. or we can say that where clause is used to check for extra or additional conditions.

Syntax:

case let(myElement1, myElement2) where "condition":
     // body

Example:

// Swift program to illustrate the 
// working of where clause with switch statement

// Initializing a tuple
var myTuple = (20, 10)

// Switch block 
switch myTuple
{

    // If myElement1 is thrice of myElement2
    case let (myElement1, myElement2) where myElement1 == 3 * myElement2:
      
        // Then print
        print("myElement1 is thrice of myElement2")
    
    // If myElement1 is twice of myElement2
    case let (myElement1, myElement2) where myElement1 == 2 * myElement2:
     
        // Then print
        print("myElement1 is twice of myElement2")
    
    // If myElement1 is equal to myElement2
    case let (myElement1, myElement2) where myElement1 ==  myElement2:
    
        // Then print
        print("myElement1 is equal to myElement2")
    
    default:
    
        // Then print
        print("Invalid")
}

Output:

myElement1 is twice of myElement2

Using compound cases with a switch statement

In Swift, we are allowed to use compound cases with a switch statement. The case conditions that share a common body can be clubbed together using commas (,). Or we can say when multiple cases separated by comma have the same body then the cases are known as compound cases. In compound cases, if any pattern matches the switch condition then that case is considered to be a match. This technique should be followed whenever required as it reduces the code size and improves the quality of our code.

Syntax:

case condition1, condition2, ....:
    // body

Example:

// Swift program to illustrate the compound cases

// Initializing a character
var myCharacter = "B"

// Switch block 
switch myCharacter
{

    // If myCharacter is equal to either "A" or "B"
    case "A", "B":
    
        // Then print "Either Apple or Boy"
        print("Either Apple or Boy")
    
    // If myCharacter is equal to "C"  
    case "C":
    
        // Then print "Cat" 
        print("Cat")
    
    // If myCharacter is equal to "D"   
    case "D":
    
        // Then print "Dog"   
        print("Dog")
    
    // Default statement
    default:
        print("Invalid")
}

Output:

Either Apple or Boy

bhuwanesh

Follow

Improve

Article Tags :

• Swift