Switch statement in Swift

Question

I\'m learning syntax of Swift and wonder, why the following code isn\'t working as I expect it to:

for i in 1...100{

    switch (i){
    case 1:
        Int         


        

Answer 1

The industry standard behaviour of switch can lead to bugs similar to "Go to Fail".

Basically the code doesn't always do exactly what it looks like the code will do when reading over it, which leads to code auditors skipping over critical bugs.

To counter that, Apple has decided switch statements should not work the same in Swift as the industry standard. In particular:

• There is an automatic break at the end of every case. It's impossible for more than one case statement to execute.
• If it's theoretically possible for one of the case statements to be missed, then the code will not compile at all. In swift one of the case statements will always execute, no matter what value is provided. If you provide an enum, every enum value must be handled. If a new value is added to an existing enum the code won't compile until new case statements are added. If you provide a 32 bit integer, you must handle every possible value of a 32 bit int.

Answer 2

This is a more general answer for people who come here just wanting to know how to use the switch statement in Swift.

General usage

switch someValue {
case valueOne:
    // executable code
case valueTwo:
    // executable code
default:
    // executable code
}

Example

let someValue = "horse"

switch someValue {
case "horse":
    print("eats grass")
case "wolf":
    print("eats meat")
default:
    print("no match")
}

Notes:

• No break statement is necessary. It is the default behavior. Swift switch cases do not "fall through". If you want them to fall through to the code in the next case, you must explicitly use the fallthrough keyword.
• Every case must include executable code. If you want to ignore a case, you can add a single break statement.
• The cases must be exhaustive. That is, they must cover every possibly value. If it is not feasible to include enough case statements, a default statement can be included last to catch any other values.

The Swift switch statement is very flexible. The following sections include some other ways of using it.

Matching multiple values

You can match multiple values in a single case if you use separate the values with commas. This is called a compound case.

let someValue = "e"

switch someValue {
case "a", "b", "c":
    // executable code
case "d", "e":
    // executable code
default:
    // executable code
}

You can also match whole intervals.

let someValue = 4

switch someValue {
case 0..<10:
    // executable code
case 10...100:
    // executable code
default:
    // executable code
}

You can even use tuples. This example is adapted from the documentation.

let aPoint = (1, 1)

switch aPoint {
case (0, 0):
    // only catches an exact match for first and second
case (_, 0):
    // any first, exact second
case (-2...2, -2...2):
    // range for first and second
default:
    // catches anything else
}

Value Bindings

Sometimes you might want to create a temporary constant or variable from the switch value. You can do this right after the case statement. Anywhere that a value binding is used, it will match any value. This is similar to using _ in the tuple example above. The following two examples are modified from the documentation.

let anotherPoint = (2, 0)

switch anotherPoint {
case (let x, 0):
    // can use x here
case (0, let y):
    // can use y here
case let (x, y):
    // can use x or y here, matches anything so no "default" case is necessary
}

You can further refine the matching by using the where keyword.

let yetAnotherPoint = (1, -1)

switch yetAnotherPoint {
case let (x, y) where x == y:
    // executable code
case let (x, y) where x == -y:
    // executable code
case let (x, y):
    // executable code
}

Further study

• This answer was meant to be a quick reference. Please read the full documentation for more. It isn't difficult to understand.

Answer 3

Switch statements in Swift support value bindings.
This allows you to assign a value that matches a certain condition (evaluated via the where clause) to a temporary variable (x & y here):

for i in 1...100 {
    switch (i){
    case let x where x%3 == 0:
        println("Fizz")
    case let y where y%5 == 0:
        println("Buzz")
    default:
        println("\(i)")
    }
}

You could also use the assigned temp value in the case body.

Update:
Matt Gibson points out in the comments, that you can omit the assignment to a temp var if you are not going to use it in the case body.
So a more concise version of the above code would be:

for i in 1...100 {
    switch (i){
    case _ where i%3 == 0:
        println("Fizz")
    case _ where i%5 == 0:
        println("Buzz")
    default:
        println("\(i)")
    }
}

Side note: Your 2 code samples are slightly different (the first one uses the range 0-100 as input, while the second one operates on 1-100). My sample is based on your first code snippet.

Answer 4

Here are the two ways I use switch statement for this kind of problems .

1>> Using where keyword

func printNumberType(number : Int){
    
    switch number {
    case number where number % 3 == 0 && number % 5 == 0 :
        print("foo bar")
    case number where number % 3 == 0 :
        print("foo")
    case number where number % 5 == 0 :
        print("bar")
    default :
        print("Number is not divisible by 3 and 5")
    }
}

2>> Using values combination

func printNumberByMultipleValues(number : Int){
    
    let combination = (number % 3,number % 5)
    
    switch combination {
    case (0,0):
        print("foo bar")
    case (0,_) :
        print("foo")
    case (_,0) :
        print("bar")
    default :
        print("Number is not divisible by 3 and 5")
    }
}

Here is closer example for multiple value type .

var printNumberByMultipleValues : (Int)->() = { number in
    
    let combination = (number % 3,number % 5)
    
    switch combination {
    case (0,0):
        print("foo bar")
    case (0,_) :
        print("foo")
    case (_,0) :
        print("bar")
    default :
        print("Number is not divisible by 3 and 5")
    }
}

Answer 5

Use this code. Your logic is wrong. Your Switch Statement does not find the case accept 1 and 2

class TEST1{
func print() -> Void{
    var i = 0
    for i in 1...100{
        if Int(i%3) == 0 {
            println("Fizz")
        }
        else if Int(i%5) == 0{
            println("Buzz")
        }
        else {
            println("\(i)")
        }   
    }
}
}
var x = TEST1()
x.print()

Answer 6

The usual rules for the FizzBuzz game are to replace every multiple of 3 by "Fizz", every multiple of 5 by "Buzz", and every multiple of both 3 and 5 by "FizzBuzz".

This can be done with a switch statement on the tuple (i % 3, i % 5). Note that _ means "any value":

for i in 1 ... 100 {
    switch (i % 3, i % 5) {
    case (0, 0):
        print("FizzBuzz")
    case (0, _):
        print("Fizz")
    case (_, 0):
        print("Buzz")
    default:
        print(i)
    }
}