Golang For 循环教程 [With Examples]

探索 Golang 的循环结构：从基础到高级应用

通过几个实用示例，深入了解 Golang 的 for 循环的方方面面。

近年来，像 Rust、Golang 和 TypeScript 这样的编程语言在开发者中越来越受欢迎。如果你对后端开发和 DevOps 领域感兴趣，那么学习 Golang 将是一个明智的选择！

对于编程初学者而言，循环结构是需要优先掌握的基础概念之一。

Golang 只提供 for 循环这一种循环结构。我们将探讨 for 循环的用法，并展示如何使用它来模拟其他类型的循环。

让我们开始学习吧！

Golang for 循环的语法结构

在 Golang 中，你可以使用以下语法来创建一个 for 循环：

for 初始化语句; 循环条件; 更新语句 {
    // 循环体
}

其中：

• 初始化语句：用于初始化循环变量。
• 循环条件：决定循环体是否执行的条件。只要条件为真，循环体就会重复执行。当条件为假时，循环结束。
• 更新语句：用于更新循环变量，通常是递增或递减操作。

请注意，这与 C 语言中的 for 循环相似，只是 Golang 中不需要括号。

以下是 Golang 中 for 循环的控制流程：

是时候开始编写一些代码示例了！你可以选择在本地安装的 Golang 环境中进行编码，也可以在 Go Playground 上运行这些示例。

Golang for 循环示例

让我们使用刚刚学到的语法，编写第一个 for 循环。这个简单的循环将以 1 为步长打印从 1 到 5 的数字。

package main

import "fmt"

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

我们初始化循环变量 i 为 1，设置循环条件为 i <= 5，并在每次迭代后将循环变量递增 1。以下是输出结果：

//输出
For loop:
1
2
3
4
5

再来看一个 for 循环的例子。这个循环从 5 开始，倒数到 1；只要循环变量大于或等于 1，循环就继续执行。因此，我们在每次迭代后将循环变量递减 1。

package main

import "fmt"

func main() {
  fmt.Println("For loop:")
  num := 5
  for i := num; i >= 1; i-- {
    fmt.Println(i)
  }
}

我们得到了预期的输出：

//输出
For loop:
5
4
3
2
1

循环变量的作用域

循环变量的作用域仅限于 for 循环的代码块内，在循环外部无法访问。

为了验证这一点，让我们尝试在循环外访问循环变量 i 的值：

package main

import "fmt"

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

正如预期的那样，我们会收到一个错误，指出 i 是一个未定义的变量，因为它仅在 for 循环内有效：

// 输出
./prog.go:11:14: undefined: i

Golang 中的无限循环

我们可以在 Go 中创建无限循环吗？答案是肯定的！

回顾一下 for 循环的控制流程：

• 只要循环条件的结果为真，循环体就会持续执行。
• 当循环条件变为假时，循环结束。
• 因此，如果循环条件永远不会变为假（或始终为真），那么我们就会得到一个无限循环。

此外，你也可以在没有初始化语句、循环条件和更新语句的情况下使用 for 循环，而不会引发语法错误。因此，即使使用这种形式的 for 循环结构，你也可以创建一个无限循环：

package main

import "fmt"

func main() {
  for {
    fmt.Println("running...")
  }
}

//输出
running...
running...
running...
running...
running...
//循环将永远执行！

在这个例子中，我们将变量 num 设置为 5。循环条件是 num > 0。因此，只要 num 大于 0，循环就会一直运行。

package main

import "fmt"

func main() {
  num := 5
  for num > 0 {
    fmt.Println(num)
  }
}

由于 num 的值永远不会改变，所以条件总是为真，循环将无限执行！

//输出
5
5
5
5
5
5
//循环将永远执行！

在 Golang 中，只存在 for 循环这一种结构，我们可以尝试使用 for 循环来模拟 while 和 do-while 循环的行为。让我们学习如何实现！

使用 for 循环模拟 while 循环

while 循环通常采用以下形式：

// 初始化循环变量
while (循环条件){
    // 循环体
    // 更新循环变量
} 

如果你还记得，在我们创建的第一个无限 for 循环中，我们使用了以下形式的 for 循环：没有初始化语句、循环条件和更新语句。

for {
// 最简单的无限循环
}

因此，我们可以修改 for 循环，使其仅包含循环条件（如下所示），从而模拟 while 循环：

// 初始化循环变量
for 循环条件 {
  // 循环体
  // 更新循环变量
}

以下是我们之前编写的第一个 for 循环的等效 while 循环的模拟版本：

package main

import "fmt"

func main() {
  fmt.Println("模拟 while 循环")
  num := 5
  for num > 0 {
    fmt.Println(num)
    num--
  }
}

//输出
模拟 while 循环
5
4
3
2
1

使用 for 循环模拟 do-while 循环

如果你使用过 C 等语言进行编程，你就会知道 do-while 循环结构采用以下形式：

// 初始化循环变量
do {
// 循环体
// 更新循环变量
} while(循环条件);

while 循环和 do-while 循环的主要区别在于，while 循环在进入循环时检查条件，而 do-while 循环在退出循环时检查条件。

因此，在 while 循环中，如果条件一开始就为假，则循环体永远不会执行。但是，在 do-while 循环中，即使条件为假，循环体也会至少执行一次。

基于这些信息，我们可以通过以下方式模拟 do-while 循环的行为：

• 编写一个无限循环
• 使用带有正确条件的 if 条件语句来跳出循环

假设你想编写一个 do-while 循环，其中循环体执行的条件是 num < 0。因此，你可以编写一个 for 循环，并在 num >= 0 时跳出循环。

package main

import "fmt"

func main() {
  fmt.Println("模拟 do-while 循环")
  num := 5
  for {
    fmt.Println("循环正在运行...")
    if num >= 0 {
      break
    }
  }
}

💡 注意：在 num < 0 时执行循环，以及在 num >= 0 时跳出循环，是等价的条件。

尽管条件 num > 0 最初为假（因为 num 为 5），但循环体仍然执行了一次，从而模拟了 do-while 循环的行为。

//输出
模拟 do-while 循环
循环正在运行...

使用 for 循环遍历数组

在 Golang 中使用 for 循环和 range 关键字遍历数组时，你可以同时访问数组的索引和元素。这类似于 Python 中的 enumerate 函数。

在这里，我们创建了一个名为 numArray 的整数数组，并使用 for 循环遍历它：

package main

import "fmt"

func main() {
  fmt.Println("遍历数组")
  numArray := []int{3, 7, 0, 10, 8, 9}
  for idx, num := range numArray {
    fmt.Println("索引为", idx, ": ", num)
  }
}

正如你所看到的，我们可以同时访问索引和每个索引对应的元素：

//输出
遍历数组
索引为 0 :  3
索引为 1 :  7
索引为 2 :  0
索引为 3 :  10
索引为 4 :  8
索引为 5 :  9

在 Golang for 循环中使用 defer

在 Golang 中，你可以使用 defer 关键字来延迟函数的调用。

虽然 defer 主要用于资源清理和错误处理等场景，但了解如何在 for 循环中使用 defer 也会有所帮助。让我们看看在 for 循环中使用 defer 来延迟对 Println() 函数的调用时会发生什么。

package main

import "fmt"

func main() {
  fmt.Println("For loop:")
  num := 5
  for i := 1; i <= num; i++ {
    defer fmt.Println(i)
  }
}

💬 当函数调用被延迟时，函数调用会被压入栈中，并以 LIFO（后进先出）的顺序执行。这个执行过程只发生在 defer 语句所在的函数返回之后。

因此，fmt.Println(5) 会最先执行，而 fmt.Println(1) 会最后执行：

//输出
For loop:
5
4
3
2
1

总结

以下是本教程中你所学内容的总结：

• 在 Golang 中，你可以使用以下语法创建一个 for 循环：for 初始化语句; 循环条件; 更新语句 { // 循环体 }。
• for 循环的控制流程很简单：循环变量初始化一次，循环条件决定是否执行循环体，更新语句则是在每次迭代后更新循环变量。
• 循环变量的作用域仅限于循环体内，在循环外部无法访问。
• 虽然 Golang 只提供 for 循环这一种循环结构，但你可以使用 for 循环来模拟 while 和 do-while 循环的行为。
• for 循环的其他应用包括遍历数组，以及延迟在 for 循环体内调用的函数。

接下来，学习如何在 Python 中使用 for 循环。祝你学习愉快！🎉