作者简介：

        高科，先后在 IBM PlatformComputing从事网格计算，淘米网，网易从事游戏服务器开发，拥有丰富的C++，go等语言开发经验，mysql，mongo，redis等数据库，设计模式和网络库开发经验，对战棋类，回合制，moba类页游，手游有丰富的架构设计和开发经验。 （谢谢你的关注）

--------------------------------------------------------------------------------------------------------------------------------

前言        

         Go 语言提供了 for 循环语句，用于重复执行一段程序逻辑，直到循环条件不再满足时终止。

          循环可以用于迭代各种数据结构（例如切片、数组、映射或字符串）中的元素

        本文将很基础的for循环语法，循环嵌套，无限循环，goto，break，continue呈现给正在学习go开发的读者。         

for

语法

Go语言的for循环有3中形式，只有其中的一种使用分号。

    for init; condition; post { }

    for condition { }

    for { }

    init： 一般为赋值表达式，给控制变量赋初值；

    condition： 关系表达式或逻辑表达式，循环控制条件；

    post： 一般为赋值表达式，给控制变量增量或减量。

for语句执行过程如下：

    ①先对表达式 init 赋初值；

    ②判别赋值表达式 init 是否满足给定 condition 条件，若其值为真，满足循环条件，则执行循环体内语句，然后执行 post，进入第二次循环，再判别 condition；否则判断 condition 的值为假，不满足条件，就终止for循环，执行循环体外语句。   

s := "abc"
for i, n := 0, len(s); i < n; i++ { // 常见的 for 循环，支持初始化语句。
    println(s[i])
}
n := len(s)
for n > 0 {                // 替代 while (n > 0) {}
    n-- 
    println(s[n])        // 替代 for (; n > 0;) {}
}
for {                    // 替代 while (true) {}
    println(s)            // 替代 for (;;) {}
}  

不要期望编译器能理解你的想法，在初始化语句中计算出全部结果是个好主意。

package main
func length(s string) int {
    println("call length.")
    return len(s)
}
func main() {
    s := "abcd"
    for i, n := 0, length(s); i < n; i++ {     // 避免多次调用 length 函数。
        println(i, s[i])
    } 
}  

输出:

    call length.

    0 97

    1 98

    2 99

    3 100 

for-range

range类似迭代器操作，返回 (索引, 值) 或 (键, 值)。

for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：

for key, value := range oldMap {
    newMap[key] = value
}   

	1st value	2nd value
string	index	s[index]	unicode, rune
array/slice	index	s[index]
map	key	m[key]
channel	element

可忽略不想要的返回值，或 "_" 这个特殊变量。

1. 迭代字符串

该for-range循环可用于访问字符串中的各个字符。

package main
import "fmt"
func main() {
  for i, ch := range "World" {
    fmt.Printf("%#U starts at byte position %d\n", ch, i)
  }
}

以上实例运行输出结果为:

U+0057 'W' starts at byte position 0
U+006F 'o' starts at byte position 1
U+0072 'r' starts at byte position 2
U+006C 'l' starts at byte position 3
U+0064 'd' starts at byte position 4

2. 迭代map

该for-range循环可用于访问映射中的各个键值对。

package main
import "fmt"
func main() {
  m := map[string]int{
    "one":   1,
    "two":   2,
    "three": 3,
  }
  for key, value := range m {
      fmt.Println(key, value)
  }
}

输出结果：

one 1 
two 2 
three 3 

3. 迭代通道

对于通道，迭代值是在通道关闭之前在通道上发送的连续值。

package main
import "fmt"
func main() {
  mychannel := make(chan int)
  go func() {
      mychannel <- 1
      mychannel <- 2
      mychannel <- 3
      close(mychannel)
  }()
  for n := range mychannel {
      fmt.Println(n)
  }
}

输出：

1
2
3

循环嵌套

在 for 循环中嵌套一个或多个 for 循环

语法

以下为 Go 语言嵌套循环的格式：

for [condition |  ( init; condition; increment ) | Range]
{
   for [condition |  ( init; condition; increment ) | Range]
   {
      statement(s)
   }
   statement(s)
}  

实例：

下面这个例子使用了两个 for 循环来实现循环嵌套。外层的循环变量为 i，范围是 1 到 3，内层的循环变量为 j，范围也是 1 到 3。

package main
import "fmt"
func main() {
    for i := 1; i <= 3; i++ {
        for j := 1; j <= 3; j++ {
            fmt.Printf("i: %d, j: %d\n", i, j)
        }
    }
}

最终的输出结果为：：

i: 1, j: 1

i: 1, j: 2

i: 1, j: 3

i: 2, j: 1

i: 2, j: 2

i: 2, j: 3

i: 3, j: 1

i: 3, j: 2

i: 3, j: 3

无限循环

如过循环中条件语句永远不为 false 则会进行无限循环，我们可以通过 for 循环语句中只设置一个条件表达式来执行无限循环：

package main
import "fmt"
func main() {
    for true  {
        fmt.Printf("这是无限循环。\n");
    }
}  

细心的读者可能已经发现了实际上for true {} 和for {}是等价的，所以这两种方式都可以，只不过在阅读代码的时候你需要知道这种方式。 

goto、break、continue

如果你有其他语言的开发基础，我i想你对这三个关键词很熟悉， 同样的在Go中，goto、break和continue也是三种控制流语句，用于改变程序的执行顺序

goto语句：

• 语法：goto label
• 作用：无条件跳转到指定的标签处执行，可以跳转到同一个函数或代码块内的任意位置。
• 注意事项：goto语句应该慎用，因为滥用goto会导致代码难以理解和维护。

  示例代码：

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

  break语句：

  • 语法：break
  • 作用：跳出循环体或switch语句，结束当前循环或switch语句的执行，继续执行循环或switch之后的代码。
  • 注意事项：break语句只能用于循环体或switch语句的内部，不可用于其他地方。

    示例代码：

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

    continue语句：

    • 语法：continue
    • 作用：终止当前迭代，跳过本次循环中continue语句之后的代码，开始下一次迭代。
    • 注意事项：continue语句只能用于循环体内部，不可用于其他地方。

      示例代码：

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

      • goto语句用于无条件跳转到指定位置执行，慎用。
      • break语句用于结束当前循环或switch语句的执行，继续执行之后的代码。
      • continue语句用于跳过本次循环的剩余代码，开始下一次迭代。 
         查域名ip地址查询  深圳网站建设手机版  建站软件有哪些  钓鱼网站案例  做公司网站找谁  沈阳建设工程信息网