Go 编程实例【For 循环】

ゝ一纸荒年。 2023-10-08 21:38 67阅读 0赞

#### 阅读目录 ####

*  基础实例
 *  简述 for 循环语法
 *   *  break
     *  continue
 *  示例
 *   *  打印出从 0 到 10 所有的偶数
     *  for 循环中声明和操作多个变量
     *  无限循环

## 基础实例 ##

for 是 Go 中唯一的循环结构。

这里有 for 循环 的三个基本使用方式。

// for.go
    package main
    
    import "fmt"
    
    func main() {
        
    
    	// 最基础的方式，单个循环条件。
    	i := 1
    	for i <= 3 {
        
    		fmt.Println(i)
    		i = i + 1
    	}
    
    	// 经典的初始/条件/后续 `for` 循环。
    	for j := 7; j <= 9; j++ {
        
    		fmt.Println(j)
    	}
    
    	// 不带条件的 `for` 循环将一直重复执行，直到在循环体内使用
    	// 了 `break` 或者 `return` 来跳出循环。
    	for {
        
    		fmt.Println("loop")
    		break
    	}
    
    	// 你也可以使用 `continue` 来跳到下一个循环迭代
    	for n := 0; n <= 5; n++ {
        
    		if n%2 == 0 {
        
    			continue
    		}
    		fmt.Println(n)
    	}
    }

[root@bogon test]# go run for.go
    1
    2
    3
    7
    8
    9
    loop
    1
    3
    5
    [root@bogon test]#

## 简述 for 循环语法 ##

循环语句是用来重复执行某一段代码。

for 是 Go 语言唯一的循环语句。

Go 语言中并没有其他语言比如 C 语言中的 while 和 do while 循环。

for initialisation; condition; post {
        
    }

初始化语句只执行一次，循环初始化后，将检查循环条件。

如果条件的计算结果为 true ，则 `{}` 内的循环体将执行，接着执行 `post` 语句。post 语句将在每次成功循环迭代后执行。在执行 post 语句后，条件将被再次检查。如果为 true, 则循环将继续执行, 否则 for 循环将终止。

> （译注：这是典型的 for 循环三个表达式，  
> 第一个为初始化表达式或赋值语句；  
> 第二个为循环条件判定表达式；  
> 第三个为循环变量修正表达式，即此处的 post ）

这三个组成部分，即初始化，条件和 post 都是可选的。

让我们看一个例子来更好地理解循环。

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

在上面的程序中，i 变量被初始化为 1。条件语句会检查 i 是否小于 10。如果条件成立，i 就会被打印出来，否则循环就会终止。循环语句会在每一次循环完成后自增 1。一旦 i 变得比 10 要大，循环中止。

上面的程序会打印出 1 2 3 4 5 6 7 8 9 10 。

在 for 循环中声明的变量只能在循环体内访问，因此 i 不能够在循环体外访问。

### break ###

break 语句用于在完成正常执行之前突然终止 for 循环，之后程序将会在 for 循环下一行代码开始执行。

让我们写一个从 1 打印到 5 并且使用 break 跳出循环的程序。

package main
    
    import (
        "fmt"
    )
    
    func main() {
        
        for i := 1; i <= 10; i++ {
        
            if i > 5 {
        
                break //loop is terminated if i > 5
            }
            fmt.Printf("%d ", i)
        }
        fmt.Printf("\nline after for loop")
    }

在上面的程序中，在循环过程中 i 的值会被判断。

如果 i 的值大于 5 然后 break 语句就会执行，循环就会被终止。

打印语句会在 for 循环结束后执行，上面程序会输出为：

1 2 3 4 5
    line after for loop

### continue ###

continue 语句用来跳出 for 循环中当前循环。

在 continue 语句后的所有的 for 循环语句都不会在本次循环中执行。

循环体会在一下次循环中继续执行。

让我们写一个打印出 1 到 10 并且使用 continue 的程序。

package main
    
    import (
        "fmt"
    )
    
    func main() {
        
        for i := 1; i <= 10; i++ {
        
            if i%2 == 0 {
        
                continue
            }
            fmt.Printf("%d ", i)
        }
    }

在上面的程序中，这行代码 if i%2==0 会判断 i 除以 2 的余数是不是 0，如果是 0，这个数字就是偶数然后执行 continue 语句，从而控制程序进入下一个循环。

因此在 continue 后面的打印语句不会被调用而程序会进入一下个循环。

上面程序会输出 `1 3 5 7 9`。

## 示例 ##

### 打印出从 0 到 10 所有的偶数 ###

package main
    
    import (
        "fmt"
    )
    
    func main() {
        
        i := 0
        // initialisation and post are omitted
        for ;i <= 10; {
         
            fmt.Printf("%d ", i)
            i += 2
        }
    }

0 2 4 6 8 10

正如我们已经知道的那样，for 循环的三部分，初始化语句、条件语句、post 语句都是可选的。

在上面的程序中，初始化语句和 post 语句都被省略了。

i 在 for 循环外被初始化成了 0。  
只要 i<=10 循环就会被执行。  
在循环中，i 以 2 的增量自增。  
上面的程序会输出 `0 2 4 6 8 10`。

上面程序中 for 循环中的分号也可以省略。  
这个格式的 for 循环可以看作是二选一的 for while 循环。  
上面的程序可以被重写成：

package main
    
    import (
        "fmt"
    )
    
    func main() {
        
        i := 0
         //semicolons are ommitted and only condition is present
        for i <= 10 {
        
            fmt.Printf("%d ", i)
            i += 2
        }
    }

### for 循环中声明和操作多个变量 ###

在 for 循环中可以声明和操作多个变量。

让我们写一个使用声明多个变量来打印下面序列的程序。

10 * 1 = 10
    11 * 2 = 22
    12 * 3 = 36
    13 * 4 = 52
    14 * 5 = 70
    15 * 6 = 90
    16 * 7 = 112
    17 * 8 = 136
    18 * 9 = 162
    19 * 10 = 190

package main
    
    import (
        "fmt"
    )
    
    func main() {
        
    	//multiple initialisation and increment
        for no, i := 10, 1; i <= 10 && no <= 19; i, no = i+1, no+1 {
         
            fmt.Printf("%d * %d = %d\n", no, i, no*i)
        }
    
    }

在上面的程序中 no 和 i 被声明然后分别被初始化为 10 和 1 。

在每一次循环结束后 no 和 i 都自增 1 。  
布尔型操作符 && 被用来确保 i 小于等于 10 并且 no 小于等于 19 。

### 无限循环 ###

无限循环的语法是：

for {
        
    }

下一个程序就会一直打印Hello World不会停止。

package main
    
    import "fmt"
    
    func main() {
        
        for {
        
            fmt.Println("Hello World")
        }
    }