Golang Tutorial - Switch Statement

This chapter covers the Switch Statement in Go (Golang). We will explore how to write clean conditional logic using simple switches, handle multiple conditions in a single case, and leverage Go's powerful Type Switch to inspect dynamic types at runtime.

1. The Problem: Why Do We Need Switch Statements?

When writing software, we frequently need to execute different blocks of code based on the value of a variable. While this can be achieved using nested if-else blocks, doing so for a large number of conditions quickly leads to cluttered, hard-to-read, and difficult-to-maintain code.

The Naive Approach (if-else chains)

if i == 1 {
    fmt.Println("one")
} else if i == 2 {
    fmt.Println("two")
} else if i == 3 {
    fmt.Println("three")
} else {
    fmt.Println("other")
}

The Better Approach (switch)

A switch statement provides a cleaner, more declarative way to bind multiple conditional branches to a single control variable. It improves code readability and allows the compiler to optimize the jump tables behind the scenes.

2. Simple Switch Statement in Go

In Go, a basic switch statement evaluates an expression and compares its result against a list of values defined in case clauses.

Code Implementation

Create a file named switch.go inside a folder named switch:

package main

import "fmt"

func main() {
    i := 5

    switch i {
    case 1:
        fmt.Println("one")
    case 2:
        fmt.Println("two")
    case 3:
        fmt.Println("three")
    default: // Optional fallback case
        fmt.Println("other")
    }
}

Output (when i = 5)

other

Note: The default case is completely optional. If no cases match and there is no default case, the program simply continues execution after the switch block without throwing an error.

3. Key Differences: Go vs. Other Languages (The Implicit Break)

If you are coming from languages like C, C++, Java, or JavaScript, you might notice a major syntactic difference: Go does not require an explicit break statement at the end of each case.

In Go, once a matching case is found, its block executes, and control immediately exits the switch statement.

4. Multiple Conditions in a Single Case

Go allows you to group multiple values into a single case statement by separating them with commas. This is highly useful when different inputs share the same execution logic.

Real-World Example: Checking for Weekends

We can use Go's standard library time package to check if the current day is a weekday or a weekend.

package main

import (
    "fmt"
    "time"
)

func main() {
    // time.Now().Weekday() returns the current day (Sunday, Monday, etc.)
    switch time.Now().Weekday() {
    case time.Saturday, time.Sunday:
        fmt.Println("It's weekend")
    default:
        fmt.Println("It's work day")
    }
}

How it Works:

• time.Now().Weekday() evaluates to the current day of the week.
• The first case checks if the value matches either time.Saturday or time.Sunday.
• If it matches neither, the default block executes.

5. First-Class Functions & The Empty Interface (interface{})

Before diving into Type Switches, we must understand two foundational Go concepts used in the implementation:

1. First-Class Functions: In Go, functions are first-class citizens. This means you can assign functions to variables, pass them as arguments to other functions, and return them from functions.
2. The Empty Interface (interface{} or any): An empty interface can hold values of any dynamic type (e.g., int, string, bool, custom structs). It acts as a placeholder for unknown or generic data types.

6. Type Switch: Checking Dynamic Types at Runtime

A Type Switch is a unique and powerful construct in Go. Instead of comparing values, it compares the type of an interface variable.

Syntax

To perform a type switch, we use the syntax variable.(type) inside the switch guard:

switch t := i.(type) {
    // cases check types instead of values
}

Code Implementation

Below, we define an anonymous function whoAmI assigned to a variable, which accepts an empty interface parameter and inspects its type:

package main

import "fmt"

func main() {
    // Function assigned to a variable (First-Class Function)
    whoAmI := func(i interface{}) {
        switch t := i.(type) {
        case int:
            fmt.Printf("It's an integer (Value: %v)\n", t)
        case string:
            fmt.Println("It's a string")
        case bool:
            fmt.Println("It's a boolean")
        default:
            fmt.Printf("Other type: %T\n", t)
        }
    }

    // Testing with different types
    whoAmI("golang") // String
    whoAmI(10)       // Integer
    whoAmI(true)     // Boolean
    whoAmI(7.8)      // Float64 (falls to default)
}

Output

It's a string
It's an integer (Value: 10)
It's a boolean
Other type: float64

7. Step-by-Step Code Evolution of Type Switch

Depending on whether you need to access the underlying value of the variable, Go allows two variations of the Type Switch syntax.

Variation A: Capturing both Type and Value (Assigned Switch)

Use this when you need to use the casted value (t) inside your case blocks.

switch t := i.(type) {
case int:
    // 't' is treated as an int here
    fmt.Println("Integer value multiplied by 2:", t * 2)
}

Variation B: Checking Type Only (Unassigned Switch)

If you only need to identify the type and do not need to manipulate the value, you can omit the variable assignment.

switch i.(type) {
case int:
    fmt.Println("It's an integer")
case string:
    fmt.Println("It's a string")
}

8. Complete Flow Walkthrough

Below is the execution flow of how Go processes a Type Switch when a value is passed to the whoAmI function:

Summary and Key Takeaways

• No Nested If-Else Clutter: Use switch statements to simplify complex conditional logic branches.
• No Explicit Breaks: Go automatically breaks out of switch cases; you do not need to write break at the end of every case.
• Optional Default: The default case acts as a fallback and is completely optional.
• Comma-Separated Cases: Multiple expressions can be grouped into a single case (e.g., case time.Saturday, time.Sunday:).
• First-Class Functions: Functions can be assigned to variables and passed around dynamically.
• Empty Interface (interface{}): Represents any data type in Go, serving as the basis for dynamic type checking.
• Type Switch (i.(type)): A powerful Go-specific construct used to determine and handle the dynamic type of an interface variable at runtime.