Noop for Swift's Exhaustive Switch Statements

Swift requires exhaustive switch statements, and that each case have executable code.

> 'case' label in a 'switch' should have at least one executable statement

Has anybody settled on a good way to handle the cases where you don't want to actually do anything? I can put a println() in there, but that feels dirty.

According to the book, you need to use break there:

> The scope of each case can’t be empty. As a result, you must include at least one statement following the colon (:) of each case label. Use a single break statement if you don’t intend to execute any code in the body of a matched case.

You can use a break statement:

let vegetable = "red pepper"
var vegetableComment: String = "Nothing"
switch vegetable {
case "cucumber", "watercress":
    break // does nothing
case let x where x.hasSuffix("pepper"):
    vegetableComment = "Is it a spicy \(x)?"
default:
    vegetableComment = "Everything tastes good in soup."
}

Example modified from the docs

Below is one option for null statement, but maybe not a good solution. I cannot find a statement like python pass

{}() 

for switch case, break is better choice.

break

In addition to break mentioned in other answers, I have also seen () used as a no-op statement:

switch 0 == 1 {
case true:
    break
case false:
    ()
}

Use () if you find break confusing or want to save 3 characters.

Do nothing in exhaustive switch case statements:

Swift:

switch yourVariable {
case .someCase:
    break
}

SwiftUI:

switch yourVariable {
case .someCase:
    EmptyView() // break does not work with ViewBuilder
}

Using EmptyView() instead of break in SwiftUI views prevents the error:

> Closure containing control flow statement cannot be used with function > builder ViewBuilder.

EmptyView() is a SwiftUI standard view (tested with Xcode 12, iOS 14) and does not need to be defined yourself.

The cleanest solution I've found is to simply include your last statement in the switch case as your default. This avoids the need to add break or other unnecessary statements while still covering all possible cases.

For example:

switch myVar {

case 0:
    myOtherVar = "Red"

case 1:
    myOtherVar = "Blue"

default:
    myOtherVar = "Green"

}

You can check specific case, no need to be exhustive with switch cases

Say you have a enum like this,

enum Selection {
        case one
        case two
        case three
    }
var myCase = Selection.one
    

you can check like this,

    if case .one = myCase {
        print("one")
    }

A clean solution I use for my default case is:

default: ()