Day04（循环语句）

有几种常见的循环方式，主要包括 for 循环、range 循环以及带有 break 和 continue 关键字的循环。这些循环可以用来遍历数组、切片、映射（map）、字符串、通道（channel）等。下面详细介绍每种循环的用法和示例

for

基本的 for 循环

package main

import "fmt"

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

这个示例中的 for 循环从 0 循环到 4，总共执行 5 次。

省略初始和后置语句的 for 循环

package main

import "fmt"

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

这个示例中的 for 循环只包含条件语句，初始语句和后置语句都省略了。

无限循环

package main

import "fmt"

func main() {
  i := 0
  for {
    fmt.Println(i)
    i++
    if i >= 5 {
      break
    }
  }
}

这个示例展示了一个无限循环，通过 break 语句跳出循环。

range 循环

range 循环用于遍历数组、切片、映射、字符串和通道。

遍历数组或切片

package main

import "fmt"

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

这个示例使用 range 循环遍历一个切片，打印出每个元素的索引和值。

遍历映射

package main

import "fmt"

func main() {
  personAge := map[string]int{"Alice": 30, "Bob": 25}
  for name, age := range personAge {
    fmt.Printf("Name: %s, Age: %d\n", name, age)
  }
}

这个示例使用 range 循环遍历一个映射，打印出每个键值对。

遍历字符串

package main

import "fmt"

func main() {
  str := "Hello, 世界"
  for index, runeValue := range str {
    fmt.Printf("Index: %d, Rune: %c\n", index, runeValue)
  }
}

这个示例使用 range 循环遍历一个字符串，打印出每个字符的索引和值（以 Unicode 码点表示）。

遍历通道

package main

import "fmt"

func main() {
  ch := make(chan int, 5)
  ch <- 1
  ch <- 2
  ch <- 3
  close(ch)

  for value := range ch {
    fmt.Println(value)
  }
}

这个示例使用 range 循环遍历一个通道，直到通道被关闭。

使用 break 和 continue

break 语句

break 语句用于立即退出循环。

package main

import "fmt"

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

这个示例中的循环会在 i 等于 5 时退出。

continue 语句

continue 语句用于跳过当前循环的剩余部分，立即开始下一次循环迭代。

package main

import "fmt"

func main() {
  for i := 0; i < 10; i++ {
    if i%2 == 0 {
      continue
    }
    fmt.Println(i)
  }
}

这个示例中的循环会跳过所有偶数，只打印奇数。

特殊用法

在 Go 语言的 for 循环中，可以使用一些特殊的语法和关键字来控制循环的执行流程，包括 goto、标签、break、continue 等。这些工具可以帮助我们更灵活地控制循环。下面介绍这些特殊用法并提供相应的示例。

使用 goto 跳转

goto 语句可以跳转到代码中的标签位置。标签是由标签名和冒号组成的一行代码。

示例：使用 goto 跳转

package main

import "fmt"

func main() {
  i := 0

Loop:
  for i < 10 {
    if i == 5 {
      i++
      goto Loop
    }
    fmt.Println(i)
    i++
  }
}

在这个例子中，当 i 等于 5 时，goto Loop 语句将控制权转移到标签 Loop 所在的位置，从而跳过了 i 等于 5 的情况。输出结果为：0 1 2 3 4 6 7 8 9。

使用标签与 break 和 continue

在 Go 中，break 和 continue 可以与标签一起使用，以便在多层嵌套循环中控制特定的循环。

示例：带标签的 break

package main

import "fmt"

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

在这个例子中，break OuterLoop 将跳出外层循环。输出结果为：

i=0, j=0
i=0, j=1
i=0, j=2
i=1, j=0

示例：带标签的 continue

package main

import "fmt"

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

在这个例子中，continue OuterLoop 将跳到外层循环的下一次迭代。输出结果为：

i=0, j=0
i=0, j=1
i=0, j=2
i=1, j=0
i=2, j=0
i=2, j=1
i=2, j=2

在 for 循环中使用 defer

defer 语句在函数结束时才会执行，但是在循环中，每次迭代都会注册一个新的 defer 调用，当函数结束时，所有的 defer 调用会按照逆序执行。

示例：在循环中使用 defer

package main

import "fmt"

func main() {
  for i := 0; i < 3; i++ {
    defer fmt.Println(i)
  }
}

在这个例子中，循环中每次迭代都会注册一个 defer 调用。当 main 函数结束时，defer 调用按照逆序执行。输出结果为：

2
1
0

使用 return 退出函数

在 for 循环中，可以使用 return 语句来直接退出整个函数。

示例：使用 return 退出函数

package main

import "fmt"

func main() {
  for i := 0; i < 10; i++ {
    if i == 5 {
      return
    }
    fmt.Println(i)
  }
}

在这个例子中，当 i 等于 5 时，return 语句将退出整个 main 函数。输出结果为：

0
1
2
3
4