Go语言控制流程（2）

_yingty_

于 2025-03-25 08:30:00 发布

阅读量937

点赞数 9

文章标签： golang python 开发语言

本文链接：https://blog.csdn.net/m0_73558214/article/details/146488785

版权

Go语言控制流程

续上

1. `fallthrough`语句

1.1 什么是`fallthrough`语句

在Go语言的switch语句中，fallthrough是一个特殊的关键字。在其他语言（如C、Java）的switch语句中，每个case分支默认会贯穿执行，即执行完一个case后会继续执行下一个case，除非使用break语句来终止。而在Go语言中，switch语句的case分支默认是不会贯穿执行的，每个case执行完后就会自动跳出switch语句。fallthrough关键字的作用就是打破这种默认行为，让程序继续执行下一个case分支。

1.2 `fallthrough`语句的使用示例

下面是一个简单的示例代码，展示了fallthrough语句的使用：

package main

import "fmt"

func main() {
    num := 2
    switch num {
    case 1:
        fmt.Println("数字是1")
    case 2:
        fmt.Println("数字是2")
        fallthrough
    case 3:
        fmt.Println("数字是3")
    default:
        fmt.Println("数字不是1、2、3")
    }
}

1.3 代码解释

在上述代码中，我们定义了一个变量num并赋值为2。
进入switch语句，由于num的值为2，所以执行case 2分支，打印出“数字是2”。
由于case 2分支中使用了fallthrough语句，程序会继续执行下一个case分支，即case 3分支，打印出“数字是3”。
最后程序结束。

1.4 运行结果

数字是2
数字是3

1.5 使用`fallthrough`的注意事项

fallthrough语句必须是case分支的最后一条语句。如果fallthrough后面还有其他语句，编译器会报错。
fallthrough会直接执行下一个case分支，而不会再对下一个case的条件进行判断。

2. `for`循环

2.1 仅带条件子句的`for`语句

2.1.1 语法结构

for 条件表达式 {
    // 循环体
}

这种形式的for循环类似于其他语言中的while循环，只要条件表达式的值为true，就会一直执行循环体。

2.1.2 示例代码

package main

import "fmt"

func main() {
    i := 1
    for i <= 5 {
        fmt.Println(i)
        i++
    }
}

2.1.3 代码解释

首先定义一个变量i并初始化为1。
进入for循环，判断条件i <= 5是否为true。由于i初始值为1，满足条件，所以执行循环体，打印出i的值，并将i的值加1。
再次判断条件i <= 5，只要条件为true，就会继续执行循环体，直到i的值变为6，此时条件不满足，循环结束。

2.1.4 运行结果

2.2 带三个子句的`for`语句

2.2.1 语法结构

for 初始化语句; 条件表达式; 后置语句 {
    // 循环体
}

初始化语句：在循环开始前执行一次，通常用于初始化循环变量。
条件表达式：在每次循环开始前进行判断，如果为true，则执行循环体；如果为false，则结束循环。
后置语句：在每次循环体执行完毕后执行，通常用于更新循环变量。

2.2.2 示例代码

package main

import "fmt"

func main() {
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
    }
}

2.2.3 代码解释

初始化语句i := 1将循环变量i初始化为1。
条件表达式i <= 5判断i是否小于等于5，如果是，则执行循环体，打印出i的值。
后置语句i++将i的值加1。
重复上述步骤，直到i的值变为6，此时条件表达式为false，循环结束。

2.2.4 运行结果

2.3 枚举集合元素语句

在Go语言中，可以使用for...range语句来枚举集合（如数组、切片、映射等）中的元素。

2.3.1 枚举数组元素

package main

import "fmt"

func main() {
    numbers := [5]int{1, 2, 3, 4, 5}
    for index, value := range numbers {
        fmt.Printf("索引: %d, 值: %d\n", index, value)
    }
}

2.3.2 代码解释

定义一个包含5个元素的整数数组numbers。
使用for...range语句遍历数组，index表示当前元素的索引，value表示当前元素的值。
每次循环打印出当前元素的索引和值。

2.3.3 运行结果

索引: 0, 值: 1
索引: 1, 值: 2
索引: 2, 值: 3
索引: 3, 值: 4
索引: 4, 值: 5

2.3.4 枚举切片元素

切片的for...range遍历方式与数组类似：

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    for index, value := range numbers {
        fmt.Printf("索引: %d, 值: %d\n", index, value)
    }
}

2.3.5 枚举映射元素

package main

import "fmt"

func main() {
    person := map[string]string{
        "name":    "John",
        "age":     "30",
        "country": "USA",
    }
    for key, value := range person {
        fmt.Printf("键: %s, 值: %s\n", key, value)
    }
}

2.3.6 代码解释

定义一个映射person，包含姓名、年龄和国家信息。
使用for...range语句遍历映射，key表示映射的键，value表示映射的值。
每次循环打印出当前键和值。

2.3.7 运行结果

键: name, 值: John
键: age, 值: 30
键: country, 值: USA

2.4 `continue`与`break`语句

2.4.1 `continue`语句

continue语句用于跳过当前循环体的剩余部分，直接进入下一次循环。

package main

import "fmt"

func main() {
    for i := 1; i <= 5; i++ {
        if i == 3 {
            continue
        }
        fmt.Println(i)
    }
}

2.4.2 代码解释

当i的值为3时，遇到continue语句，跳过当前循环体的剩余部分（即不执行fmt.Println(i)），直接进入下一次循环。
因此，程序不会打印出3。

2.4.3 运行结果

2.4.4 `break`语句

break语句用于提前终止循环，无论循环条件是否满足。

package main

import "fmt"

func main() {
    for i := 1; i <= 5; i++ {
        if i == 3 {
            break
        }
        fmt.Println(i)
    }
}

2.4.5 代码解释

当i的值为3时，遇到break语句，直接终止整个循环，不再执行后续的循环。
因此，程序只打印出1和2。

2.4.6 运行结果

1
2

3. 代码跳转

3.1 代码标签与`goto`语句

3.1.1 语法结构

标签:
    // 代码块
goto 标签

goto语句用于无条件地跳转到指定的标签处继续执行代码。

3.1.2 示例代码

package main

import "fmt"

func main() {
    i := 1
Loop:
    if i <= 5 {
        fmt.Println(i)
        i++
        goto Loop
    }
}

3.1.3 代码解释

定义一个变量i并初始化为1。
定义一个标签Loop，标签后面是一个if语句。
如果i小于等于5，则打印出i的值，并将i的值加1，然后使用goto语句跳转到Loop标签处继续执行。
重复上述步骤，直到i的值变为6，此时if条件不满足，程序结束。

3.1.4 运行结果

3.2 `break`、`continue`语句与代码跳转

break和continue语句也可以结合代码标签使用，用于跳出或继续指定的循环。

3.2.1 `break`语句结合标签

package main

import "fmt"

func main() {
OuterLoop:
    for i := 1; i <= 3; i++ {
        for j := 1; j <= 3; j++ {
            if i == 2 && j == 2 {
                break OuterLoop
            }
            fmt.Printf("i: %d, j: %d\n", i, j)
        }
    }
}

3.2.2 代码解释

定义一个外层循环和一个内层循环。
当i的值为2且j的值为2时，使用break OuterLoop语句跳出外层循环，不再执行后续的循环。

3.2.3 运行结果

i: 1, j: 1
i: 1, j: 2
i: 1, j: 3
i: 2, j: 1

3.2.4 `continue`语句结合标签

package main

import "fmt"

func main() {
OuterLoop:
    for i := 1; i <= 3; i++ {
        for j := 1; j <= 3; j++ {
            if i == 2 && j == 2 {
                continue OuterLoop
            }
            fmt.Printf("i: %d, j: %d\n", i, j)
        }
    }
}

3.2.5 代码解释

定义一个外层循环和一个内层循环。
当i的值为2且j的值为2时，使用continue OuterLoop语句跳过外层循环的剩余部分，直接进入下一次外层循环。

3.2.6 运行结果

i: 1, j: 1
i: 1, j: 2
i: 1, j: 3
i: 2, j: 1
i: 3, j: 1
i: 3, j: 2
i: 3, j: 3

结论

Go语言的控制流程语句为开发者提供了丰富的选择，能够满足各种不同的编程需求。通过合理使用fallthrough语句、for循环以及代码跳转机制，可以编写出高效、灵活的程序。对于初学者来说，掌握这些控制流程语句是迈向编程进阶的重要一步。希望本文能够帮助你更好地理解和使用Go语言的控制流程。