Go语言流程控制（二）

switch语句

Go 语言中的 switch 语句是一种选择结构，用于基于不同条件执行不同的代码块。Go 的 switch 相较于其他语言的 switch 有一些独特的特点，使其更为灵活和强大。下面是Go语言中 switch 语句的详细介绍：

基本语法

switch expression {
case value1:
    // 当 expression 等于 value1 时执行的代码
case value2:
    // 当 expression 等于 value2 时执行的代码
// ... 可以有多个 case
default:
    // 如果没有任何 case 匹配，则执行这里的代码
}

• expression: 用于比较的表达式，可以是任何类型。
• case : 每个 case 后面跟着一个或多个值，如果这些值与 expression 的结果相等，则执行该 case 下的代码。
• default: 可选，当没有任何 case 匹配时执行，默认情况可以出现在任何位置，甚至在 case 之前。

特点和注意事项

1. 自动break ：Go 的 switch 语句在匹配到一个 case 并执行完对应的代码块后会自动 break，这意味着它不会继续执行下一个 case，除非使用 fallthrough 关键字。

2. 类型匹配：case 后的值与 switch 表达式的结果不必严格相等，只要类型兼容且值相等即可。例如，整数和浮点数之间如果值相等也能匹配。

3. fallthrough ：如果一个 case 后面跟随 fallthrough 关键字，那么即使当前 case 匹配，也会继续执行下一个 case，直到遇到 break 或到达 default。

4. 省略switch后的表达式：在某些情况下，可以省略 switch 后的表达式，这时它会根据 case 直接判断。

5. 多值匹配：一个 case 可以匹配多个值，只需用逗号分隔这些值。

示例

基础示例

package main

import "fmt"

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

//运行结果:Wednesday

fallthrough

package main

import "fmt"

func main() {
	score := 69
	switch {
	case score < 60:
		fmt.Println("Failed")
	case score < 70:
		fmt.Println("bad")
		fallthrough
	case score < 50:
		fmt.Println("Passed")
	case score <= 100:
		fmt.Println("Excellent")
	}
}

//运行结果
//bad
//Passed

在Go语言中，fallthrough 是一个关键字，用于 switch 语句中。它的作用是控制 switch 语句执行的流程，在匹配到当前 case 之后，直接继续执行紧接着的下一个 case，即使下一个 case 的条件没有被满足。这与许多其他编程语言中的 switch 语句默认行为不同，在那些语言中，一旦一个 case 匹配成功并执行后，会自动退出 switch 语句，除非显式使用 break 语句。

省略表达式

package main

import "fmt"

func main() {
    switch {
    case true:
        fmt.Println("This will always print.")
    }
}

//运行结果: This will always print.

多值匹配

package main

import "fmt"

func main() {
    x := 3
    switch x {
    case 1, 3, 5:
        fmt.Println("Odd number")
    case 2, 4, 6:
        fmt.Println("Even number")
    }
}

//运行结果: Odd number

goto语句

Go语言中 goto 语句通过标签进行代码间的无条件跳转，同时 goto 语句在快速跳出循环、避免重复退出上也有一定的帮助，使用 goto 语句能简化一些代码的实现过程。

使用 goto 退出多层循环

下面这段代码在满足条件时，需要连续退出两层循环，使用传统的编码方式如下：

package main
import "fmt"
func main() {
    var breakAgain bool
    // 外循环
    for x := 0; x < 10; x++ {
        // 内循环
        for y := 0; y < 10; y++ {
            // 满足某个条件时, 退出循环
            if y == 2 {
                // 设置退出标记
                breakAgain = true
                // 退出本次循环
                break
            }
        }
        // 根据标记, 还需要退出一次循环
        if breakAgain {
                break
        }
    }
    fmt.Println("done")
}

将上面的代码使用Go语言的 goto 语句进行优化：

package main
import "fmt"
func main() {
    for x := 0; x < 10; x++ {
        for y := 0; y < 10; y++ {
            if y == 2 {
                // 跳转到标签
                goto breakHere
            }
        }
    }
    // 手动返回, 避免执行进入标签
    return
    // 标签
breakHere:
    fmt.Println("done")
}

break

break 语句用于提前终止循环，使程序跳出当前循环结构。在多层嵌套循环中，你可以通过结合标签（labeled statement）来指定跳出哪一层循环。

基本用法

在最简单的情况下，break 用于立即结束最近的 for 循环。

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i == 5 {
            break // 当 i 等于5时，跳出循环
        }
        fmt.Println(i)
    }
}

带标签的 break

如果在嵌套循环中需要跳出外层循环，可以在外层循环前定义一个标签，并在内层循环使用 break 加标签名来跳出指定的循环。

package main

import "fmt"

func main() {
outerLoop:
    for i := 0; i < 3; i++ {
        for j := 0; j < 3; j++ {
            if i*j == 2 {
                break outerLoop // 跳出外层循环
            }
            fmt.Printf("(%d, %d)\n", i, j)
        }
    }
    fmt.Println("外层循环已结束")
}

continue

continue 语句用于跳过当前循环迭代中剩余的部分，直接开始下一次迭代。这对于在满足特定条件时跳过循环体中的一些操作非常有用。

基本用法

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i%2 == 0 { // 如果i是偶数
            continue // 跳过本次循环的剩余部分，直接进行下一次迭代
        }
        fmt.Println(i) // 因此，这里只打印奇数
    }
}

注意事项

• continue 仅影响它所在的最直接的循环迭代，不会影响外部循环。
• 与 break 类似，continue 也可以配合标签使用来影响带有特定标签的循环迭代，但这在实际编程中较少见。

参考文章：Go语言goto语句------跳转到指定的标签 (biancheng.net)