Type Switch Statement

A type switch is a control flow construct that performs a series of type assertions on an interface value. Instead of comparing values, it compares the dynamic type of the interface against a set of specified types, executing the block of code associated with the first matching type.

package main

import "fmt"

func main() {
    var interfaceValue any = "golang"

    switch interfaceValue.(type) {
    case int:
        // Executes if the dynamic type is int
        fmt.Println("Type is int")
    case string, bool:
        // Executes if the dynamic type is string or bool
        fmt.Println("Type is string or bool")
    case nil:
        // Executes if the interface value has no dynamic type
        fmt.Println("Interface is nil")
    default:
        // Executes if no other cases match
        fmt.Println("Unknown type")
    }
}

Core Mechanics

The TypeSwitchGuard and .(type) Operator The syntax i.(type) is syntactically similar to a standard type assertion, but the keyword type replaces the specific type identifier. This construct is strictly reserved for use within the TypeSwitchGuard (the switch expression) of a switch block and cannot be evaluated as a standalone expression.

Optional Initialization Statement Like standard expression switches, a type switch can include an optional initialization statement that precedes the TypeSwitchGuard. The initialization statement and the guard are separated by a semicolon (e.g., switch init(); v := i.(type) { ... }).

Variable Binding and Type Inference When the TypeSwitchGuard includes a short variable declaration (e.g., v := i.(type)), the compiler binds a new variable v within each case block. The static type of v depends on the structure of the case:

• Single-Type Case: If the case specifies exactly one type (e.g., case string: or case io.Reader:), the variable v is strongly typed as that specific type within the block.
• Multiple-Type Case: If the case specifies a comma-separated list of types (e.g., case int, float64:), the variable v retains the original interface type of the evaluated expression.
• Default Case: Within the default block, the variable v retains the original interface type.

Interface Types in Cases A case can specify an interface type rather than a concrete type. When an interface type is evaluated, the type switch checks whether the dynamic type of the value implements that interface, rather than checking for strict type equality. If the implementation check succeeds, the bound variable v takes on the static type of that matched interface.

The nil Case A type switch can explicitly match nil. This case evaluates to true if the interface value itself has no dynamic type (e.g., an uninitialized interface or an interface explicitly assigned nil).

Fallthrough Restriction Unlike standard expression switches in Go, the fallthrough statement is strictly prohibited within a type switch. The compiler will reject any attempt to fall through from one type case to the next.

Structural Example

package main

import (
    "fmt"
    "io"
    "strings"
)

func evaluateType(i any) {
    // Optional initialization statement (val := i) followed by the TypeSwitchGuard
    switch val := i; v := val.(type) {
    case int:
        // v is statically typed as 'int' here.
        // Safe to perform integer operations.
        fmt.Printf("Integer: %d\n", v+10)
    case io.Reader:
        // Interface type case: matches if the dynamic type implements io.Reader.
        // v is statically typed as 'io.Reader' here.
        buf := make([]byte, 4)
        _, _ = v.Read(buf)
        fmt.Printf("Reader contains: %s\n", string(buf))
    case string, bool:
        // Multiple types specified.
        // v remains statically typed as 'any' (interface{}).
        fmt.Printf("String or Bool: %v\n", v)
    case nil:
        // val is a nil interface (no dynamic type).
        // v remains statically typed as 'any'.
        fmt.Println("Value is nil")
    default:
        // No types matched.
        // v remains statically typed as 'any'.
        fmt.Printf("Default case: %T\n", v)
    }
}

func main() {
    evaluateType(42)
    evaluateType(strings.NewReader("test"))
    evaluateType(true)
    evaluateType(nil)
    evaluateType(3.14)
}

Master Go with Deep Grasping Methodology!

Learn More