【30天熟悉Go语言】8 Go流程控制之循环结构for range、goto、break、continue

客官°小女子只卖身不卖艺 2023-10-12 14:16 47阅读 0赞

#### 文章目录 ####

*  一、前言
 *  二、for循环
 *   *  1、语法
     *   *  1）和Java的for循环一样
         *  2）和Java的while一样
         *  3）和Java的for(;;)一样
     *  2、for语句执行过程
 *  三、for range
 *   *  1、语法
     *   *  1）遍历key、value
         *   *  只遍历value
         *  2）遍历key
 *  四、关键字
 *   *  1、break
     *   *  1）双重/多层for循环中使用
         *  3）通过标签指定要结束的for循环
     *  2、continue
     *   *  1）双重/多层for循环中使用
         *  2）通过标签指定要continue的for循环
     *  3、goto
     *  4、return
 *  五、总结
 *   *  对比Java来看

## 一、前言 ##

![在这里插入图片描述][26456da6bcf74d8ab70094e321fbd199.png]

Go系列文章：

> 1.  [GO开篇：手握Java走进Golang的世界][GO_Java_Golang]
> 2.  [2 Go开发环境搭建、Hello World程序运行][2 Go_Hello World]
> 3.  [3 Go编程规约和API包][3 Go_API]
> 4.  [4 Go的变量、常量、运算符][4 Go]
> 5.  [5 Go 基本数据类型][5 Go]
> 6.  [6 Go 复杂数据类型之指针][6 Go]
> 7.  [7 Go流程控制之分支结构if、switch][7 Go_if_switch]

**Go专栏传送链接：[https://blog.csdn.net/saintmm/category\_12326997.html][https_blog.csdn.net_saintmm_category_12326997.html]**

## 二、for循环 ##

for 循环是一个循环控制结构，可以指定循环执行的次数  
![在这里插入图片描述][78c826f0cbb54343a35a9540cc465dce.png]

### 1、语法 ###

Go的for循环有三种方式，仅有一种方式需要像Java一样使用分号。

#### 1）和Java的for循环一样 ####

for init; condition; post {
         }

*  init： 给控制变量赋初值，一般为：赋值表达式；
 *  condition： 循环控制条件，一般为：关系表达式或逻辑表达式；
 *  post： 给控制变量增量或减量，一般为：赋值表达式。

**示例：计算1 到 100 的数字之和：**

package main
    
    import "fmt"
    
    func main() {
        
    	sum := 0
    	for i := 1; i <= 100; i ++ {
        
    		sum += i
    	}
    	fmt.Println(sum)
    }

**控制台输出：**  
![在这里插入图片描述][f9719fb62bbe411fb69dada190cf71ed.png]

#### 2）和Java的while一样 ####

for condition {
         }

init和post参数是可选的，针对上面的实例，我们可以省略它俩，这样的for循环语句就类似于while循环。

**示例：当sum 小于 100事，计算sum自加的结果**

package main
    
    import "fmt"
    
    func main() {
        
    	sum := 1
    	for sum < 100 {
        
    		sum += sum
    	}
    	fmt.Println(sum)
    }

**控制台输出：**  
![在这里插入图片描述][e8f21a99f8a64a92808a9a9b8ddf3716.png]

#### 3）和Java的for(;;)一样 ####

无限循环，也等价于while(true)；

for {
         }

**示例：**

package main
    
    import "fmt"
    
    func main() {
        
    	sum := 0
    	// 无限循环下去
    	for {
        
    		sum++
    	}
    	// 永远执行不到这条语句
    	fmt.Println(sum)
    }

**想要停止无限循环，在命令窗口按下ctrl + c 。**

### 2、for语句执行过程 ###

1.  先执行赋值表达式，对变量赋初始化值；
2.  执行condition表达式，判断赋值表达式init中的变量是否符合条件；
    
     *  符合循环条件，这执行循环体内的语句；然后执行post表达式，进入第二次循环。在判断condition。
     *  不符合循环条件，终止for循环，执行循环体之外的go语句。

## 三、for range ##

for range结构是Go语言特有的一种迭代结构，可以遍历数组、切片、字符串、map、通道，语法上类似于Java中的 foreach 语句。

### 1、语法 ###

Go的for range循环有两种方式；

#### 1）遍历key、value ####

for key, value := range coll {
        
        .....
    }

**示例：遍历字符串、数组**

package main
    
    import "fmt"
    
    func main() {
        
    	// 遍历字符串
    	str := "Hello World"
    	for i, value := range str {
        
    		fmt.Printf("第 %d 位 char 的值 = %c\n", i, value)
    
    	}
    
    	// 遍历数组
    	numbers := [6]int{
        1, 2, 3, 5}
    	for i, num:= range numbers {
        
    		fmt.Printf("第 %d 位 num 的值 = %d\n", i, num)
    	}
    }

**控制台输出：**

![在这里插入图片描述][3fbf7886b4a449eda860c22639007cfb.png]

##### 只遍历value #####

只遍历value 和 遍历 key/value的唯一区别在于用标识符`_`接收key。

for _, value := range coll {
        
        .....
    }

**示例：遍历字符串**

package main
    
    import "fmt"
    
    func main() {
        
    	// 遍历字符串的char值
    	str := "Hello World"
    	for _, value := range str {
        
    		fmt.Printf("各位的 char值 = %c\n", value)
    
    	}
    }

#### 2）遍历key ####

遍历key仅需要接收key，不需要使用标识符`_`接收value。语法如下：

for key := range coll {
        
        .....
    }

**示例：遍历数组值**

package main
    
    import "fmt"
    
    func main() {
        
    	// 遍历数组中的值
    	numbers := [4]int{
        1, 2, 3, 5}
    	for num:= range numbers {
        
    		fmt.Println(num)
    	}
    }

**控制台输出：**  
![在这里插入图片描述][c7c08b493f474d318b21ce57ab561a49.png]

## 四、关键字 ##

Go流程控制中常用的关键字有四个：break、continue、goto、return

### 1、break ###

break用于立即中断for循环。

**示例：**

package main
    
    import "fmt"
    
    func main() {
        
    	sum := 0
    	for i := 1; i <= 100; i ++ {
        
    		sum += i
    		if sum > 100 {
        
    			fmt.Println("即将退出循环")
    			break
    		}
    	}
    	fmt.Println(sum)
    }

**控制台输出：**  
![在这里插入图片描述][1475afb8c6af43c485af8e954b0ca63e.png]

#### 1）双重/多层for循环中使用 ####

双重for循环中，break只会影响到最近的for循环；

**示例：**

package main
    
    import "fmt"
    
    func main() {
        
    	for i := 1; i <= 2; i++ {
        
    		for j := i; j < 10; j++ {
        
    			if j == 8  {
        
    				fmt.Println("即将退出内层循环，开启下一个外层循环")
    				break
    			}
    			fmt.Printf("i = %d, j = %d \n", i, j)
    		}
    	}
    	fmt.Println("done")
    }

**控制台输出：**  
![在这里插入图片描述][3820942745fc434dbbbea22356b590eb.png]

#### 3）通过标签指定要结束的for循环 ####

break也可以通过for循环定义的标签，控制break对哪个for循环生效。

**示例：**

package main
    
    import "fmt"
    
    func main() {
        
    outerFor:
    	for i := 1; i <= 2; i++ {
        
    		for j := i; j < 10; j++ {
        
    			if j == 8 {
        
    				fmt.Println("即将退出外层循环")
    				break outerFor
    			}
    			fmt.Printf("i = %d, j = %d \n", i, j)
    		}
    	}
    	fmt.Println("done")
    }

**控制台输出：**  
![在这里插入图片描述][ca4c0a651a4d445a8b6a4d3cf25913dc.png]

### 2、continue ###

continue用于控制结束本次 循环体的代码逻辑，继续进行for循环中的下一次循环体。

**示例：统计1-10的总和，但是不加8**

package main
    
    import "fmt"
    
    func main() {
        
    	sum := 0
    	for i := 1; i <= 10; i++ {
        
    		if i == 8 {
        
    			fmt.Printf("sum总和不累加：%d \n", i)
    			continue
    		}
    		sum += i
    	}
    	fmt.Println(sum)
    }

**控制台输出：**  
![在这里插入图片描述][c9b3b7f744fc4fd294d0d4099aa649b2.png]

#### 1）双重/多层for循环中使用 ####

双重for循环中，continue只会影响到最近的for循环；

**示例：**

package main
    
    import "fmt"
    
    func main() {
        
    
    	for i := 1; i <= 2; i++ {
        
    		for j := i; j < 10; j++ {
        
    			if j == 8 {
        
    				fmt.Printf("即将跳过当前循环体, i = %d, j = %d \n", i, j)
    				continue
    			}
    			fmt.Printf("i = %d, j = %d \n", i, j)
    		}
    	}
    	fmt.Println("done")
    }

**控制台输出：**  
![在这里插入图片描述][34dafad33993401cb67d23fae2b6bfee.png]

#### 2）通过标签指定要continue的for循环 ####

continue也可以通过for循环定义的标签，控制continue对哪个for循环生效。

**示例：内层循环执行到j == 8时，continue外层循环，内存循环不再执行，这个和break一个效果；**

package main
    
    import "fmt"
    
    func main() {
        
    outerFor:
    	for i := 1; i <= 2; i++ {
        
    		for j := i; j < 10; j++ {
        
    			if j == 8 {
        
    				fmt.Printf("即将跳过当前循环体, i = %d, j = %d \n", i, j)
    				continue outerFor
    			}
    			fmt.Printf("i = %d, j = %d \n", i, j)
    		}
    	}
    	fmt.Println("done")
    }

**控制台输出：**

![在这里插入图片描述][7b3c32d491d14bcd833d252ec5a9f0a9.png]

### 3、goto ###

Go语言中的的 goto 关键字可以无条件地让程序跳转到指定的行；通常 goto 关键字 与 条件语句一起使用，以实现条件转移能力。

**然，在Go程序设计中不建议使用goto关键字，容易造成程序流程的混乱。**

**示例：**

package main
    
    import "fmt"
    
    func main() {
        
    
    	fmt.Println("Hello 1")
    	fmt.Println("Hello 2")
    	if 1 == 1 {
        
    		goto label
    	}
    
    	fmt.Println("Hello 3")
    	fmt.Println("Hello 4")
    label:
    	fmt.Println("Hello 5")
    	fmt.Println("Hello 6")
    
    }

**控制台输出：**  
![在这里插入图片描述][cc0d93d011ef4b6a995fac5a2e1f0fb1.png]

### 4、return ###

return关键字用于接收某一个函数；

**示例：**

package main
    
    import "fmt"
    
    func main() {
        
    
    	for i := 1; i <=100; i ++ {
        
    		fmt.Println(i)
    		if i == 18 {
        
    			return
    		}
    	}
    	fmt.Println("done")
    }

**控制台输出：**  
![在这里插入图片描述][b73d0adf7cbb4b74bf12bbe8928d675d.png]

## 五、总结 ##

go语言的for循环用于基本和Java一样；特殊注意continue / break 到指定for循环的用法。  
go的for range可以理解为Java中的foreach。

### 对比Java来看 ###

Go语言中，while（`for true`）、break、continue、return和Java中使用一样。

*  Java中的for后需要需要跟小括号`()`，Go中不需要；

Java中的for

for (int i = 1; i < 10; i++) {
        
    ....
    }

Go中的for

for i := 1; i < 10; i++ {
        
    ....
    }

[26456da6bcf74d8ab70094e321fbd199.png]: https://img-blog.csdnimg.cn/26456da6bcf74d8ab70094e321fbd199.png
[GO_Java_Golang]: https://blog.csdn.net/Saintmm/article/details/130793052
[2 Go_Hello World]: https://blog.csdn.net/Saintmm/article/details/130799639
[3 Go_API]: https://blog.csdn.net/Saintmm/article/details/130819239
[4 Go]: https://blog.csdn.net/Saintmm/article/details/130839198
[5 Go]: https://blog.csdn.net/Saintmm/article/details/130999658
[6 Go]: https://blog.csdn.net/Saintmm/article/details/131100380
[7 Go_if_switch]: https://blog.csdn.net/Saintmm/article/details/131161428
[https_blog.csdn.net_saintmm_category_12326997.html]: https://blog.csdn.net/saintmm/category_12326997.html
[78c826f0cbb54343a35a9540cc465dce.png]: https://img-blog.csdnimg.cn/78c826f0cbb54343a35a9540cc465dce.png
[f9719fb62bbe411fb69dada190cf71ed.png]: https://img-blog.csdnimg.cn/f9719fb62bbe411fb69dada190cf71ed.png
[e8f21a99f8a64a92808a9a9b8ddf3716.png]: https://img-blog.csdnimg.cn/e8f21a99f8a64a92808a9a9b8ddf3716.png
[3fbf7886b4a449eda860c22639007cfb.png]: https://img-blog.csdnimg.cn/3fbf7886b4a449eda860c22639007cfb.png
[c7c08b493f474d318b21ce57ab561a49.png]: https://img-blog.csdnimg.cn/c7c08b493f474d318b21ce57ab561a49.png
[1475afb8c6af43c485af8e954b0ca63e.png]: https://img-blog.csdnimg.cn/1475afb8c6af43c485af8e954b0ca63e.png
[3820942745fc434dbbbea22356b590eb.png]: https://img-blog.csdnimg.cn/3820942745fc434dbbbea22356b590eb.png
[ca4c0a651a4d445a8b6a4d3cf25913dc.png]: https://img-blog.csdnimg.cn/ca4c0a651a4d445a8b6a4d3cf25913dc.png
[c9b3b7f744fc4fd294d0d4099aa649b2.png]: https://img-blog.csdnimg.cn/c9b3b7f744fc4fd294d0d4099aa649b2.png
[34dafad33993401cb67d23fae2b6bfee.png]: https://img-blog.csdnimg.cn/34dafad33993401cb67d23fae2b6bfee.png
[7b3c32d491d14bcd833d252ec5a9f0a9.png]: https://img-blog.csdnimg.cn/7b3c32d491d14bcd833d252ec5a9f0a9.png
[cc0d93d011ef4b6a995fac5a2e1f0fb1.png]: https://img-blog.csdnimg.cn/cc0d93d011ef4b6a995fac5a2e1f0fb1.png
[b73d0adf7cbb4b74bf12bbe8928d675d.png]: https://img-blog.csdnimg.cn/b73d0adf7cbb4b74bf12bbe8928d675d.png