掌握Go语言：探索Go语言中的循环奇妙世界，从基础到实战（13）

在Go语言中，循环结构用于重复执行一段代码块，直到满足特定条件为止。Go语言提供了三种主要的循环结构：for循环、while循环（Go语言中没有while关键字，但可以使用for循环模拟）、range循环。

1. for 循环

for循环是Go语言中最常用的循环结构，用于按照指定的条件重复执行一段代码块。它有三种形式：

• 基本形式： 类似于C语言的for循环结构，包含初始化语句、条件表达式和后置语句。

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

示例代码：

package main

import "fmt"

func main() {
    // 基本形式的for循环
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }
}
1
2
3
4
5
6
7
8
9
10

• 省略初始化语句： 如果初始化语句可以省略，那么就可以将它省略不写，但分号必须保留。

sum := 0
for ; sum < 10; {
    sum += 1
}
1
2
3
4

• 省略初始化语句和后置语句： 在循环条件表达式外部定义变量，并在循环体内更新该变量的值，省略初始化语句和后置语句。

sum := 0
for sum < 10 {
    sum += 1
}
1
2
3
4

2. range 循环

range循环用于遍历数组、切片、映射或通道中的元素，并返回索引和值。

for index, value := range collection {
    // 使用 index 和 value
}
1
2
3

示例代码：

package main

import "fmt"

func main() {
    // 遍历数组
    arr := []int{1, 2, 3, 4, 5}
    for index, value := range arr {
        fmt.Printf("Index: %d, Value: %d\n", index, value)
    }

    // 遍历映射
    m := map[string]int{"a": 1, "b": 2, "c": 3}
    for key, value := range m {
        fmt.Printf("Key: %s, Value: %d\n", key, value)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3. while 循环

虽然Go语言没有while关键字，但可以使用for循环来模拟while循环的功能。只需省略初始化语句和后置语句，并只保留条件表达式即可。

sum := 0
for sum < 10 {
    sum += 1
}
1
2
3
4

除了for循环、range循环和模拟while循环外，Go语言还提供了一些其他的循环语句和控制结构，如下所示：

4. 无限循环

有时候需要创建一个没有结束条件的循环，在Go语言中可以使用for循环并省略循环条件部分，实现一个无限循环。

for {
    // 无限循环
}
1
2
3

5. 循环控制语句

在循环中，可以使用以下循环控制语句来控制循环的执行流程：

• break语句： 用于提前退出循环，跳出循环体的执行。

for i := 0; i < 10; i++ {
    if i == 5 {
        break // 提前退出循环
    }
    fmt.Println(i)
}
1
2
3
4
5
6

• continue语句： 用于跳过本次循环的剩余代码，继续执行下一次循环。

for i := 0; i < 5; i++ {
    if i == 2 {
        continue // 跳过本次循环的剩余代码
    }
    fmt.Println(i)
}
1
2
3
4
5
6

• goto语句： 用于无条件地跳转到指定标签的代码位置，通常不建议过多使用goto语句，以免造成程序流程混乱。

i := 0
loop:
for {
    fmt.Println(i)
    i++
    if i == 5 {
        goto loop // 无条件跳转到标签loop
    }
}
1
2
3
4
5
6
7
8
9

这些是Go语言中常用的循环语句和循环控制语句，在实际编程中，根据不同的需求选择合适的循环结构和控制语句，可以更加灵活地实现各种循环逻辑。

进销存实例

演示了如何使用循环结构实现一个进货模块的功能，即根据用户输入的商品数量，更新商品的库存量。

package main

import "fmt"

// 商品结构体
type Product struct {
	Name  string
	Stock int
}

// 进货函数
func purchase(product *Product, quantity int) {
	product.Stock += quantity
	fmt.Printf("成功进货 %d 个 %s\n", quantity, product.Name)
}

// 查看库存函数
func printStock(product *Product) {
	fmt.Printf("商品：%s，当前库存：%d个\n", product.Name, product.Stock)
}

func main() {
	// 创建商品
	apple := &Product{Name: "苹果", Stock: 100}
	banana := &Product{Name: "香蕉", Stock: 80}
	orange := &Product{Name: "橙子", Stock: 120}

	// 主循环，模拟简单的进货模块
	for {
		fmt.Println("\n=== 进货模块 ===")
		fmt.Println("1. 进货苹果")
		fmt.Println("2. 进货香蕉")
		fmt.Println("3. 进货橙子")
		fmt.Println("4. 查看所有商品库存")
		fmt.Println("5. 退出")

		var choice int
		fmt.Print("请输入您的选择：")
		fmt.Scanln(&choice)

		switch choice {
		case 1:
			fmt.Println("\n=== 进货苹果 ===")
			var quantity int
			fmt.Print("请输入进货数量：")
			fmt.Scanln(&quantity)
			purchase(apple, quantity)
		case 2:
			fmt.Println("\n=== 进货香蕉 ===")
			var quantity int
			fmt.Print("请输入进货数量：")
			fmt.Scanln(&quantity)
			purchase(banana, quantity)
		case 3:
			fmt.Println("\n=== 进货橙子 ===")
			var quantity int
			fmt.Print("请输入进货数量：")
			fmt.Scanln(&quantity)
			purchase(orange, quantity)
		case 4:
			fmt.Println("\n=== 所有商品库存 ===")
			printStock(apple)
			printStock(banana)
			printStock(orange)
		case 5:
			fmt.Println("感谢使用，再见！")
			return
		default:
			fmt.Println("无效的选择，请重新输入。")
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

上面这段代码是一个简单的Go语言程序，演示了一个进货模块的功能。让我们逐步解释这段代码的各个部分：

1. 导入包：导入了 fmt 包，用于格式化输入输出。

2. 定义商品结构体：Product 结构体包含商品的名称和库存数量两个字段。

3. 定义进货函数：purchase 函数用于更新商品的库存数量，接受两个参数，一个是指向 Product 结构体的指针，另一个是进货数量。

4. 定义查看库存函数：printStock 函数用于打印指定商品的名称和当前库存数量。

5. main 函数：程序的入口函数。

6. 创建商品：使用 Product 结构体创建了三种商品：苹果、香蕉和橙子，并初始化它们的库存量。

7. 主循环：通过一个无限循环模拟进货模块的功能，用户可以通过命令行菜单选择要进货的商品或查看所有商品的库存情况。

8. switch 语句：根据用户输入的选择，执行相应的操作。用户可以选择进货苹果、香蕉或橙子，查看所有商品的库存量，或退出程序。

9. 每个 case 分支都调用了相应的函数来执行对应的操作，如进货、查看库存等。

这段代码展示了如何使用循环结构、函数和条件语句来实现一个简单的进货模块，帮助用户管理商品库存。

总结

通过深入探索Go语言中的循环结构，我们不仅理解了循环的基本用法，还学会了如何利用循环实现实际场景下的功能。掌握循环，意味着能够更加高效地处理重复性任务，为Go语言编程之旅增添了无限可能。