> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Go 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.
```go theme={"dark"}
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.
```go theme={"dark"}
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.
```go theme={"dark"}
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.
```go theme={"dark"}
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.
Tired of Poor Go Skills? Fix That With Deep Grasping!
Learn More
