Go语言中布尔型Switch：逗号分隔多case与逻辑或的性能对比

Great question! Let's break this down clearly—using comma-separated cases in a Go switch is almost always going to outperform a boolean switch with logical ORs, and the reason comes down to how the Go compiler optimizes each pattern.

Why Comma-Separated Cases Are Faster #

When you use comma-separated values in a switch case (like case 1, 2, 3:), the Go compiler recognizes this as a set of constant matches and can apply aggressive optimizations:

• For small, contiguous sets of integer values, it will often convert the check into a single range comparison (e.g., x >= 1 && x <= 3), which is a single, fast operation.
• For non-contiguous but constant values, the compiler may build a jump table or hash-based lookup. This lets the runtime jump directly to the matching case logic after just one or two checks, instead of evaluating each condition sequentially.

Here's an example of this pattern:

func commaSwitch(x int) int {
    switch x {
    case 1, 2, 3, 4:
        return x * 2
    case 5, 6, 7:
        return x + 10
    default:
        return 0
    }
}

The Overhead of Boolean ORs in Switches #

On the other hand, a boolean switch (where you omit the switch expression and use case x == a || x == b:) forces the compiler to evaluate each condition in sequence. Since each || is a short-circuit check, the runtime has to test each condition one by one until it finds a match or exhausts the case.

For example:

func orSwitch(x int) int {
    switch {
    case x == 1 || x == 2 || x == 3 || x == 4:
        return x * 2
    case x == 5 || x == 6 || x == 7:
        return x + 10
    default:
        return 0
    }
}

Even if the compiler does some minor optimizations here, it can't collapse the sequential checks into the efficient lookup logic that comma-separated cases get. For cases with more than a handful of values, this sequential checking adds measurable overhead.

Edge Cases Where Differences Are Negligible #

If you only have 2-3 values to match, the performance gap might be so small you can't measure it—modern CPUs are fast enough that a couple extra comparisons won't make a dent. But as the number of matched values grows, the comma-separated approach scales far better.

Bonus: Readability #

While you asked specifically about performance, it's worth noting that comma-separated cases are also more idiomatic Go and easier to read/maintain. It's a win-win for both performance and code clarity.

内容的提问来源于stack exchange，提问作者Brian Leishman