Switch Statement in Go

Golang like most other programming languages ​​has the switch statement . The switch statement in Golang  allows you to evaluate a variable or expression in multiple cases and is often used when writing multiple if-else statements makes the code look ugly and repetitive.

In Go, a switch statement is a multi-directional branching statement that effectively directs execution based on the value (or type) of an expression. There are two main types of switch statements in Go :

• Expression Switch
• Type Switch

For example:

package main
import "fmt"

func main() {
    day := 4
    switch day {
    case 1:
        fmt.Println("Monday")
    case 2:
        fmt.Println("Tuesday")
    case 3:
        fmt.Println("Wednesday")
    case 4:
        fmt.Println("Thursday")
    case 5:
        fmt.Println("Friday")
    default:
        fmt.Println("Invalid day")
    }
}

Switch statement syntax in Golang

switch optstatement; optexpression {
case expression1:
    // Khối code
case expression2:                                                          # Expression Switch
    // Khối code
default:
    // Khối code
}

switch var := interfaceValue.(type) {
case type1:
    // Khối code
case type2:                                                                    # Type Switch
    // Khối code
default:
    // Khối code
}

Expression Switch

Expression Switch evaluates an expression and switches to a case based on the value of that expression. If no expression is provided, switch defaults to true .

Syntax

switch optstatement; optexpression {
case expression1:
    // Khối code
case expression2:
    // Khối code
default:
    // Khối code
}

optstatement: Optional statement (e.g. variable declaration).
optexpression: Optional expression (if omitted, defaults to true ).

Example with optional command

Here we introduce an optional statement that declares a variable day . The switch statement then evaluates day under various cases.

package main
import "fmt"
func main() {
    switch day := 4; day {
    case 1:
        fmt.Println("Monday")
    case 2:
        fmt.Println("Tuesday")
    case 3:
        fmt.Println("Wednesday")
    case 4:
        fmt.Println("Thursday")
    case 5:
        fmt.Println("Friday")
    default:
        fmt.Println("Invalid day")
    }
}

Result:

Thursday

Example with optional Expression

If no expression is specified, the switch statement in Golang will assume the expression is true. This allows us to use boolean conditions in case statements.

package main
import "fmt"

func main() {
    day := 4

    switch {
    case day == 1:
        fmt.Println("Monday")
    case day == 4:
        fmt.Println("Thursday")
    case day > 5:
        fmt.Println("Weekend")
    default:
        fmt.Println("Invalid day")
    }
}

Result

Thursday

Type Switch

Type Switch is used to branch on the type of an interface value, rather than its value. This is especially useful when dealing with variables of unknown type.

Syntax

switch var := interfaceValue.(type) {
case type1:
    // Khối code
case type2:
    // Khối code
default:
    // Khối code
}

For example:

This example uses the same day variable but wrapped in interface{} to illustrate type casting.

package main
import "fmt"
func main() {
    var day interface{} = 4
    switch v := day.(type) {
    case int:
        switch v {
        case 1:
            fmt.Println("Monday")
        case 2:
            fmt.Println("Tuesday")
        case 3:
            fmt.Println("Wednesday")
        case 4:
            fmt.Println("Thursday")
        case 5:
            fmt.Println("Friday")
        default:
            fmt.Println("Invalid day")
        }
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}

Result:

Thursday