Expression Switch Statement

An expression switch statement in Go is a multi-way branch control flow construct that evaluates a single expression and compares its resulting value against the values of one or more case clauses. Execution branches to the first case that equals the evaluated switch expression.

switch [initialization;] [expression] {
case expression1, expression2:
    // statements executed if expression == expression1 OR expression == expression2
case expression3:
    // statements executed if expression == expression3
default:
    // statements executed if no case matches
}

Execution Mechanics

• Evaluation Order: Go evaluates the switch expression exactly once. It then evaluates the case expressions sequentially from top to bottom, and left to right within a comma-separated list.
• Implicit Break: Unlike C or Java, Go automatically terminates the switch block at the end of a matched case. Execution does not fall through to subsequent cases by default. Explicit break statements are permitted (often used to break out of a case early) but are not required at the end of a block.
• Multiple Match Conditions: A single case can declare a comma-separated list of expressions. The case block executes if the switch expression matches any of the expressions in the list.
• Default Clause: The default case executes if no other case matches. It is optional and can be positioned anywhere within the switch block, though convention dictates placing it at the end.

Syntax Variations

Initialization Statement A switch can begin with a simple initialization statement, typically a short variable declaration, separated from the switch expression by a semicolon. Variables declared in this statement are lexically scoped to the entirety of the switch block, including all case and default clauses.

switch x := computeValue(); x {
case 1:
    // x is in scope
}
// x is out of scope

Omitted Expression If the switch expression is omitted, the compiler implicitly evaluates it as the boolean value true. Consequently, all case expressions within the block must evaluate to boolean values.

switch {
case x < y:
    // executes if x < y is true
case x > y:
    // executes if x > y is true
}

The fallthrough Keyword

To override Go’s implicit break behavior, the fallthrough keyword can be used. When executed, fallthrough immediately transfers control to the first statement of the immediately succeeding case block.

• It bypasses the evaluation of the next case’s condition entirely.
• It must be the final lexical non-empty statement within a case clause. Placing fallthrough inside a nested conditional block (such as an if statement) will result in a compile-time error, even if it represents the final runtime execution path.
• It cannot be used in the final case or default block of the switch statement.

switch expression {
case 1:
    // statements
    fallthrough // Forces execution into case 2, regardless of case 2's condition
case 2:
    // statements
}

Type Constraints

Each case expression must be comparable to the switch expression. The case expressions do not need to be comparable to one another. For example, if the switch expression is an interface type like any, one case expression can be an int and another can be a string within the same switch block.

If the switch expression evaluates to an untyped constant, it is implicitly converted to its default type (e.g., int for an integer literal, float64 for a floating-point literal) before evaluation. If a case expression has a different type that cannot be compared to this default type, it results in a compile-time error. Conversely, if a case expression is an untyped constant, it is implicitly converted to the type of the switch expression.

Master Go with Deep Grasping Methodology!

Learn More