A switch statement in Go is a control flow tool that executes different code blocks based on the value of a variable or expression. 1. The switch executes corresponding logic by matching the case, and does not support the default fall-through; 2. The conditions can be omitted and Boolean expressions are used as case judgment; 3. A case can contain multiple values, separated by commas; 4. Support type switch, which is used to dynamically check the underlying type of interface variables. This makes switch easier and more efficient than long chain if-else when dealing with multi-condition branches, value grouping and type checking.

A switch statement in Go is a control flow tool that lets you execute different blocks of code based on the value of a variable or expression. It's especially handy when you have multiple conditions to check, making your code cleaner and more readable than using a long chain of if-else statements.

Basic Syntax and How It Works

The structure of a switch statement in Go starts with the switch keyword followed by an expression (often a variable). Then come the case clauses, each checking for a specific value. When a match is found, the corresponding block runs.

Here's a simple example:

 day := "Monday"

switch day {
case "Monday":
    fmt.Println("Start of the work week.")
case "Friday":
    fmt.Println("Almost weekend!")
default:
    fmt.Println("Just another day...")
}

In this case, since day is "Monday" , it prints "Start of the work week."

Some key points:

• Only matching cases run — no fall-through by default (unlike C-style switches).
• You can use any comparable type as the condition: strings, integers, even types.
• The default clause runs if none of the cases match.

Using Switch Without a Condition

Go also allows you to write a switch without a condition. In this form, the cases contain boolean expressions, and the first one that evaluates to true gets executed.

Example:

 score := 85

switch {
case score >= 90:
    fmt.Println("A")
case score >= 80:
    fmt.Println("B")
case score >= 70:
    fmt.Println("C")
default:
    fmt.Println("Needs improvement")
}

This will print "B" because the second condition ( score >= 80 ) is true.

This style is useful when you're not comparing a single value but want to evaluate several logical conditions.

Multiple Values ??in One Case

Sometimes, you might want a block of code to run for more than one value. Go lets you list multiple values ??separated by commas in a single case .

For instance:

 letter := "e"

switch letter {
case "a", "e", "i", "o", "u":
    fmt.Println("It's a vowel.")
default:
    fmt.Println("Not a vowel.")
}

This checks if letter is any of the vowels. If yes, it prints "It's a vowel."

This feature keeps your code concise and avoids repeating similar logic across multiple cases.

Type Switch (Checking Variable Types)

Another powerful variation in Go is the type switch , which helps determine the underlying type of an interface variable.

Example:

 func describe(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Println("Integer:", v)
    case string:
        fmt.Println("String:", v)
    default:
        fmt.Println("Unknown type")
    }
}

Calling describe(42) outputs "Integer: 42" , while describe("hello") gives "String: hello" .

Type switches are particularly helpful when working with interfaces and handling different data types dynamically.

So, whether you're simplifying conditional checks, grouping values, or inspecting types, the switch statement in Go offers a clean and efficient way to manage branching logic. It's straightforward once you get used to the syntax and behavior — basically just a smarter alternative to long if-else chains.

The above is the detailed content of What is the switch statement in Go, and how does it work?. For more information, please follow other related articles on the PHP Chinese website!