[GO语言基础] 六.循环控制语句、流程控制及编程练习（for、break、continue、goto）

Love The Way You Lie 2022-10-30 01:21 237阅读 0赞

作为网络安全初学者，会遇到采用Go语言开发的恶意样本。因此从今天开始从零讲解Golang编程语言，一方面是督促自己不断前行且学习新知识；另一方面是分享与读者，希望大家一起进步。**前文介绍了Golang的顺序控制语句和条件控制语句。这篇文章将详细讲解循环控制语句和流程控制，包括for、break、continue、goto及相关编程练习。** 这系列文章入门部分将参考“尚硅谷”韩顺平老师的视频和书籍《GO高级编程》，详见参考文献，并结合作者多年的编程经验进行学习和丰富，且看且珍惜吧！后续会结合网络安全进行GO语言实战深入，加油~

这些年我学过各种编程语言，从最早的C语言到C++，再到C\#、PHP、JAVA，再到IOS开发、Python，到最新的GO语言，学得是真的杂。有时候觉得编程语言恰恰是最简单的，而通过一门编程语言能够解决实际问题或深入底层才是其价值所在，并且当我们学好一门编程语言后，其他编程语言都非常类似，殊途同归，学起来也很迅速。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center]

**源码下载地址：**

*  [https://github.com/eastmountyxz/Go-learning][https_github.com_eastmountyxz_Go-learning]

前文参考：

*  [\[GO语言基础\] 一.为什么我要学习Golang以及GO语言入门普及][GO_ _._Golang_GO]
 *  [\[GO语言基础\] 二.编译运行、语法规范、注释转义及API标准库知识普及][GO_ _._API]
 *  [\[GO语言基础\] 三.变量声明、数据类型、标识符及编程练习12题][GO_ _._12]
 *  [\[GO语言基础\] 四.算术运算、逻辑运算、赋值运算、位运算及编程练习][GO_ _.]
 *  [\[GO语言基础\] 五.顺序控制语句和条件控制语句（if、else、switch）][GO_ _._if_else_switch]
 *  [\[GO语言基础\] 六.循环控制语句、流程控制及编程练习（for、break、continue、goto）][GO_ _._for_break_continue_goto]

### 文章目录 ###

*  一.for循环控制
 *   *  1.基本语法
     *  2.for-range循环
     *  3.for编程经典案例
     *  4.类似while和do-while循环
 *  二.多重循环控制
 *   *  案例1：循环计算平均成绩
     *  案例2：循环打印金字塔和倒三角
 *  三.跳转控制语句
 *   *  1.break
     *  2.continue
 *  四.goto语句
 *  五.跳转控制语句return
 *  六.Golang编程练习
 *   *  1.题目
     *  2.解答
 *  七.总结

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

# 一.for循环控制 #

## 1.基本语法 ##

for循环的语法格式：

for 循环变量初始化; 循环条件; 循环变量迭代 { 
    	循环操作语句
    }

for循环主要有四要素，包括：

*  循环变量初始化
 *  循环条件
 *  循环操作（语句），也叫循环体
 *  循环变量迭代

for循环语句基本流程如下：

![在这里插入图片描述][20210218003139798.png_pic_center]

for循环的执行顺序说明如下：

*  执行循环变量初始化，比如 n := 1
 *  执行循环条件，比如 n <= 10
 *  如果循环条件为真，就执行循环操作
 *  执行循环变量迭代，比如i++
 *  反复执行上述三个步骤，直到循环条件为False，就退出for循环

下面举个简单的例子：

package main
    import "fmt"
    
    func main() { 
    	//for循环
    	for n := 1; n <= 10; n++ { 
    		fmt.Println("Eastmount", n)
    	}
    }

输出结果如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 1]

**for的第二种语法格式：**  
for循环条件是返回一个**布尔值**的表达式，第二种方式是将变量初始化和变量迭代写到其他位置。

for 循环判断条件 { 
    	//循环执行语句
    }

案例如下所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 2]

**for的第三种语法格式：**  
下面的写法等价于 **for; ; \{\}** ，它是一个无限循环，通常需要配合break语句使用。

for { 
    	//循环执行语句
    }

案例如下所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 3]

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

## 2.for-range循环 ##

Go语言中range关键字用于for循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回key-value对。数组后续文章介绍，这里主要介绍遍历字符串。

*  **使用for-range实现字符串遍历**

具体案例如下所示：

package main
    import "fmt"
    
    func main() { 
    	//1.for-range遍历字符串
    	str := "Eastmount CSDN"
    	for index, val := range str {   
    		fmt.Printf("index=%d, value=%c \n", index, val)
    	}
    
    	//2.for-range遍历数组
    	nums := []int{ 2, 3, 4}
    	for i, num := range nums { 
    		fmt.Printf("index=%d, value=%d \n", i, num)
    	}
    }

输出结果如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 4]

如果我们的字符串含有中文，那么传统的遍历字符串方式就会错误，会出现乱码。**原因是传统对字符串的遍历是按照字节来遍历，而一个汉字在utf8编码对应3个字节。** 如何解决呢？需要将str转换成\[\]rune切片即可。

> **rune**  
> golang中string底层是通过byte数组实现的。中文字符在unicode下占2个字节，在utf-8编码下占3个字节，而golang默认编码正好是utf-8。rune 等同于int32，常用来处理unicode或utf-8字符。  
>   
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 5]

下面展示具体的代码。

package main
    import "fmt"
    
    func main() { 
    	//1.字符串遍历-传统方法
    	str := "CSDN!秀璋"
    	str2 := []rune(str)           //将str转换成[]rune
    	for i := 0; i < len(str2); i++  {   
    		fmt.Printf("index=%d, value=%c \n", i, str2[i])
    	}
    	fmt.Println("")
    
    	//2.字符串遍历-for range
    	for index, val := range str { 
    		fmt.Printf("index=%d, value=%c \n", index, val)
    	}
    	fmt.Println("")
    
    	//3.如果不转rune直接遍历(乱码)
    	for i := 0; i < len(str); i++  {   
    		fmt.Printf("index=%d, value=%c \n", i, str[i])
    	}
    }

输出结果如下图所示，前面两种方式正确（按字节遍历），第三种方式会出现乱码。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 6]

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

## 3.for编程经典案例 ##

下面介绍各编程语言中循环都会出现的案例，计算1到100的个数及总和。

package main
    import "fmt"
    
    func main() { 
    	var result = 0
    	var num = 0
    	for i := 1; i <= 100; i++ { 
    		result += i
    		num++
    	}
    	fmt.Println("1+2+...+100 =", result)
    	fmt.Println("个数 =", num)
    }

输出结果如下图所示：

![在这里插入图片描述][20210218215721713.png_pic_center]

流程图如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 7]

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

## 4.类似while和do-while循环 ##

由于Golang只有for循环，没有while关键字和do-while语法，所以只能通过for循环来模拟while和do-while循环，即使用for+break实现。

**(1) while循环**  
for循环模拟while循环的核心代码如下图所示，需要注意：

*  for循环是一个无限循环
 *  break语句是跳出for循环

![在这里插入图片描述][20210219003709369.png_pic_center]

类似于Java或C语言的while循环语句：

int i = 0;
    while(i<10){     // notice there is only <
        do something
    }

案例如下，使用while输出10句“hello world”。

package main
    import "fmt"
    
    func main() { 
    	//类似while循环
    	var i int = 1
    	for { 
    		//循环条件
    		if i > 10 { 
    			break           //结束循环
    		}
    		fmt.Println("hello world", i)
    		i++
    	}
    }

输出结果如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 8]

**(2) do-while循环**  
由于do-while是先执行后判断，所以for循环模拟do-while循环的核心代码如下图所示：

![在这里插入图片描述][20210219004747615.png_pic_center]

需要注意：

*  由于do-while是先执行后判断，因此至少执行一次
 *  当循环条件成立后，就会执行break跳出for循环

package main
    import "fmt"
    
    func main() { 
    	//使用do-while实现输出10句"hello world"
    	var j int = 1
    	for { 
    		//先执行后判断
    		fmt.Println("hello world", j)
    		j++
    		if j > 10 { 
    			break           //结束循环
    		}
    	}
    }

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

# 二.多重循环控制 #

具体含义为：

*  将一个循环放在另一个循环体内，就形成了嵌套循环。在外边的for称为外层循环，在里面的for循环称为内层循环。建议一般使用两层，最多不要超过3层。
 *  实质上，嵌套循环就是把内层循环当成外层循环的循环体，当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可以结束外层的当次循环，开始下一次循环。
 *  设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m\*n次。

下面通过案例进行多重循环理解，这也是循环的一个难点和重点。正如韩老师所说，编程过程中遇到困难是很常见的，我们需要注意：

*  **先易后难**，将一个复杂的问题分解成简单的问题。
 *  **先死后活**，将代码写死板慢慢转变为灵活。
 *  **学会解决**，遇到困难要学会利用搜索引擎或论坛独立解决。

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

## 案例1：循环计算平均成绩 ##

题目：统计3个班成绩情况，每个班有4名同学，求出各个班的平均分和所有班级的平均分。学生的成绩从键盘输入。

*  解题思路  
    首先学会统计1个班的成绩情况，求出该班的平均分，该班为4位同学；然后考虑通过循环计算3个班的情况。

package main
    import "fmt"
    
    func main() { 
    	//求出各个班的平均分和所有班级的平均分(3个班 每个班有4名同学)
    	//解题:外层循环班级数 内存循环计算每个班级平均成绩
    	var totalsum float64 = 0.0
    	for j := 1; j <= 3; j++ {  
    		var sum float64 = 0.0
    		for i := 1; i <= 4; i++ { 
    			var score float64
    			fmt.Printf("请输入第%d班 第%d个学生的成绩 \n", j, i)
    			fmt.Scanln(&score)
    			//累计总分
    			sum += score
    		}
    		fmt.Printf("第%d个班级的平均分是%v \n", j, sum / 4)
    		//计算各个班的总结成绩
    		totalsum += sum
    	}
    	fmt.Printf("各个班级的总成绩是%v 平均分是%v \n", totalsum, totalsum / (4* 3))
    }

输出结果如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 9]

同时，为了更灵活的编写代码，我们可以尝试将循环控制常量3个班和4位同学修改为变量，具体如下：

*  var classNum int = 3
 *  var stuNum int = 4

package main
    import "fmt"
    
    func main() { 
    	//求出各个班的平均分和所有班级的平均分(3个班 每个班有4名同学)
    	//解题:外层循环班级数 内存循环计算每个班级平均成绩
    	var classNum int = 3
    	var stuNum int = 4
    	var totalsum float64 = 0.0
    
    	for j := 1; j <= classNum; j++ {  
    		var sum float64 = 0.0
    		for i := 1; i <= stuNum; i++ { 
    			var score float64
    			fmt.Printf("请输入第%d班 第%d个学生的成绩 \n", j, i)
    			fmt.Scanln(&score)
    			//累计总分
    			sum += score
    		}
    		//注意golang数据类型需要转换一致才能运算 int->float64
    		fmt.Printf("第%d个班级的平均分是%v \n", j, sum / float64(stuNum))
    		//计算各个班的总结成绩
    		totalsum += sum
    	}
    	result := totalsum / float64(stuNum * classNum)
    	fmt.Printf("各个班级的总成绩是%v 平均分是%v \n", totalsum, result)
    }

如果需要继续统计各班及格人数，怎么实现呢？

*  通过if判断语句进行比较即可

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 10]

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

## 案例2：循环打印金字塔和倒三角 ##

打印金字塔是经典的案例，在前面的第二篇文章也布置过。下面我们通过for循环打印各种金字塔，思路为：

*  两层循环，一个控制金字塔层数，一个控制每一层的输出
 *  打印图形通常由字符和空格组成，寻找对应的规律
 *  由简至繁，比如先打印矩形，再尝试半个三角形金字塔，再打印完整金字塔

首先介绍打印矩形和半个三角形金字塔代码。

package main
    import "fmt"
    
    func main() { 
    	var totalLevel int = 5
    
    	//1.打印矩形
    	for i := 1; i <= totalLevel; i++ {      //i表示层数
    		for j := 1; j <= totalLevel; j++ {  //每层输出
    			fmt.Print("*")
    		}
    		fmt.Println()  //换行
    	}
    	fmt.Println()
    
    	//2.打印正三角半个金字塔
    	for i := 1; i <= totalLevel; i++ {    //i表示层数
    		for j := 1; j <= i; j++ {         //每层输出
    			fmt.Print("*")
    		}
    		fmt.Println()  //换行
    	}
    	fmt.Println()
    
    	//3.打印倒三角半个金字塔
    	for i := 1; i <= totalLevel; i++ {    //i表示层数
    		for j := (totalLevel - i); j >= 0; j-- {        //每层输出
    			fmt.Print("*")
    		}
    		fmt.Println()  //换行
    	}
    }

输出结果如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 11]

理解上述代码之后，我们再打印金字塔，其规律为：

空格 + * + 空格
    
        *           1层 1个* 规律: 2*层数-1   空格 4个 规律:总层数-当前层数
       ***          2层 3个* 规律: 2*层数-1   空格 3个 规律:总层数-当前层数
      *****
     *******
    *********

完整代码如下，包括实心金字塔和空心金字塔。

package main
    import "fmt"
    
    func main() { 
    	/* 打印金字塔 * 1层 1个* 规律: 2*层数-1 空格 4个 规律:总层数-当前层数 *** 2层 3个* 规律: 2*层数-1 空格 3个 规律:总层数-当前层数 ***** ******* ********* */
    
    	var totalLevel int = 5
    
    	//方法一 打印实心金字塔
    	for i := 1; i <= totalLevel; i++ {                //i表示层数
    		//先打印空格
    		for j := (totalLevel - i); j >= 0; j-- { 
    			fmt.Print(" ")
    		}
    		//打印星号
    		for k := (2 * i - 1); k > 0; k-- {      
    			fmt.Print("*")
    		}
    		fmt.Println()  //换行
    	}
    	fmt.Println()
    
    	//方法二 打印空心金字塔
    	for i := 1; i <= totalLevel; i++ {                //i表示层数
    		//先打印空格
    		for j := 1; j <= (totalLevel - i); j++ { 
    			fmt.Print(" ")
    		}
    		//打印星号
    		for k := 1; k <= (2 * i - 1); k++ { 
    			//每层第一个和最后一个打印* 最底层全部打印*
    			if k == 1 || k == (2 * i - 1) || i == totalLevel { 
    				fmt.Print("*")
    			} else { 
    				fmt.Print(" ")
    			}
    		}
    		fmt.Println()  //换行
    	}
    }

输出结果如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 12]

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

# 三.跳转控制语句 #

## 1.break ##

break语句用于终止某个语句块的执行，用于中断当前for循环或跳出switch语句。基本语法如下：

{ 
    	....
    	break
    	....
    }

其示意图如下图所示（引用至韩老师）。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 13]

首先结合之前1+2+…+100介绍一个简单案例，求出当和第一次大于20的当前数字。

package main
    import "fmt"
    
    func main() { 
    	//求出当和第一次大于20的当前数字
    	sum := 0
    	for i := 1; i <= 100; i++ { 
    		sum += i   //求和
    		if sum > 20 { 
    			fmt.Println("sum大于20时当前数字是", i)
    			break  //跳出循环
    		} 
    	}
    }

输出结果如下图所示：

![在这里插入图片描述][20210219180858130.png_pic_center]

break语句的注意事项：

*  break语句出现在多层嵌套的语句块中，可以通过标签指明要终止的是哪一层语句块。
 *  break默认会跳出最近的for循环
 *  break后面可以指定标签，跳出标签对应的for循环

通过标签跳出for循环指定层的代码如下所示：

package main
    import "fmt"
    
    func main() { 
    	//通过标签跳出for循环指定层
    	label1:
    	for i := 0; i < 4; i++ { 
    		//label2:
    		for j := 0; j < 10; j++ { 
    			if j ==2 { 
    				//默认跳出最近的循环 这里尝试跳出外层循环
    				break label1
    			}
    			fmt.Println("j =", j, "i =", i)
    		}
    	} 
    }

运行结果如下，当j等于2时跳出所有循环，即调转至label1。：

![在这里插入图片描述][2021021918183682.png_pic_center]

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

## 2.continue ##

continue语句用于结束本次循环，它将继续执行下一次循环。其基本语法如下：

{ 
    	...
    	continue
    	...
    }

流程图如下所示，它将结束本次循环，继续迭代执行下一次循环。

![在这里插入图片描述][20210219182049140.png_pic_center]

同样，continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的break标签使用规则一样。

> 个人不太喜欢这个跳出指定循环层的功能，感觉代码不是很好控制。尤其是大型项目时，更建议结合实际判断条件进行跳出，当然作者理解能力尚浅，如果读者有好的应用场景可以分享与我，谢谢。

举个简单案例：

package main
    import "fmt"
    
    func main() { 
    	//continue跳出当前循环
    	for i := 0; i < 4; i++ { 
    		for j := 0; j < 10; j++ { 
    			if j ==2 { 
    				continue
    			}
    			fmt.Println("j =", j, "i =", i)
    		}
    	} 
    }

输出结果如下图所示，每次都没有输出j=2。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 14]

如果我们需要使用continue打印100以内的奇数，则可以编写如下代码：

![在这里插入图片描述][20210219182800528.png_pic_center]

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

# 四.goto语句 #

Golang中的goto语句可以无条件转移到程序中指定的行，goto常与条件语句配合使用，用以实现条件转移或跳出循环体。注意，在GO程序设计中一般不主张使用goto语句，以避免造成流程的混乱，使理解和调试程序都产生困难，同样C语言也不主张使用。

goto label
    ....
    label: statement

其执行流程如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 15]

下面介绍一个简单的案例：

package main
    import "fmt"
    
    func main() { 
    	//goto语句
    	fmt.Println("aaaaa")
    	var n int = 30
    	if n > 20 { 
    		goto label
    	}
    	fmt.Println("bbbbb")
    	fmt.Println("ccccc")
    	label:
    	fmt.Println("ddddd")
    	fmt.Println("eeeee")
    	fmt.Println("fffff")
    }

输出结果如下图所示：

![在这里插入图片描述][20210219192143475.png_pic_center]

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

# 五.跳转控制语句return #

return使用在方法或函数中，表示跳出所在的方法或函数。在分享函数的时候，我会详细介绍。

return使用说明：

*  如果return是在普通的函数，则表示跳出该函数，即不再执行函数中return后面代码，也可以理解成终止函数。
 *  如果return是在main函数，表示终止main函数，也就是终止程序。

package main
    import "fmt"
    
    func main() { 
    	//return语句
    	for i := 1; i<=10; i++ { 
    		if i==3 { 
    			return
    		}
    		fmt.Println("输出结果", i)
    	}
    	fmt.Println("over")
    }

输出结果如下图所示：

![在这里插入图片描述][20210219193002210.png_pic_center]

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

# 六.Golang编程练习 #

## 1.题目 ##

**(1) 打印1到100之间所有是9倍数的整数的个数及总和。**

**(2) 循环依次输出“East 秀璋”字符串的所有字符。**

**(3) 打印9\*9乘法表。**

**(4) 模拟网站登录验证机制.假设有3次机会，如果用户名为“Eastmount”，密码为“666666”提示登录成功，否则提示剩余机会；最终超过3次则提示“输入错误次数过多，无法登录”。**

**(5) 随机生成1到100的一个数，如果生成99这个数就停止，计算一共使用多少次。**

**(6) 输入如下4\*5的矩阵。**

1       2       3       4       5
    2       4       6       8       10
    3       6       9       12      15
    4       8       12      16      20

**(7) 利用循环求Fibonacci数列的前10个数。**

![在这里插入图片描述][20210219222323687.png_pic_center]

**(8) 求2到200间的全部素数。**

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

## 2.解答 ##

**(1) 打印1到100之间所有是9倍数的整数的个数及总和。**

代码如下：

package main
    import "fmt"
    
    func main() { 
    	var max int = 100
    	var count int = 0
    	var sum int = 0
    	for i := 1; i <= max; i++ { 
    		if i % 9 == 0 { 
    			count++
    			sum += i
    		}
    	}
    	fmt.Printf("count=%v sum=%v \n", count, sum)
    }

输出结果如下图所示：

![在这里插入图片描述][20210219201722261.png_pic_center]

**(2) 循环依次输出“East 秀璋”字符串的所有字符。**  
在数组上使用range将传入index和值两个变量。如果我们不需要使用该元素的序号，则使用空白符"\_"省略。

package main
    import "fmt"
     
    func main() { 
    	str := "East=秀璋"
    
    	//方法1
    	fmt.Printf("utf-8遍历字符串\n")
    	for _, s := range str { 
    		fmt.Printf("utf-8遍历: %c %v \n", s, s)
    	}
    	fmt.Println("")
    
    	//方法2
    	str2 := []rune(str)
    	for i := 0; i < len(str2); i++  {   
    		fmt.Printf("utf-8遍历: index=%d, value=%c \n", i, str2[i])
    	}
    	fmt.Println("")
    
    	//方法3 乱码
    	fmt.Printf("unicode遍历字符串\n")
    	for i := 0; i < len(str); i++ { 
    		ch := str[i]
    		fmt.Printf("unicode遍历: %c %d\n", ch, ch)
    	}
    }

输出结果如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 16]

**(3) 打印9\*9乘法表。**

代码如下：

package main
    import "fmt"
     
    func main() { 
    	//9*9乘法表
    	var num int = 9
    	for i := 1; i <= num; i++ { 
    		for j := 1; j <= i; j++ { 
    			fmt.Printf("%v*%v=%v \t", j, i, j*i)
    		}
    		fmt.Println()
    	}
    }

输出结果如下图所示：

![在这里插入图片描述][20210219213117143.png_pic_center]

代码如下：

package main
    import "fmt"
     
    func main() { 
    	//模拟网站登录
    	var name string
    	var pwd string
    	var loginChance = 3
    
    	for i := 1; i <= 3; i++ { 
    		//输入信息
    		fmt.Println("请输入用户名")
    		fmt.Scanln(&name)
    		fmt.Println("请输入密码")
    		fmt.Scanln(&pwd)
    		
    		if name == "Eastmount" && pwd == "666666" { 
    			fmt.Println("恭喜你登录成功")
    			break
    		} else { 
    			loginChance--
    			fmt.Printf("输入错误，你还有%v次机会\n", loginChance)
    		}
    	}
    	if loginChance <= 0 { 
    		fmt.Println("输入错误次数过多，无法登录")
    	}
    }

输出结果如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 17]

**(5) 随机生成1到100的一个数，如果生成99这个数就停止，计算一共使用多少次。**

*  提示：该题目无限循环模拟break语句，通过rand.Seed()随机生成数字，然后进行判断

package main
    import (
    	"fmt"
    	"math/rand"
    	"time"
    )
     
    func main() { 
    	//随机生成1到100的一个数，如果生成99这个数就停止
    	var count int = 0
    	for { 
    		//种子生成 使用系统时间的不确定性来进行初始化
    		rand.Seed(time.Now().UnixNano())
    		num := rand.Intn(100) + 1
    		fmt.Println("num =", num)
    		count++
    		if (num == 99) { 
    			break
    		}
    	}
    	fmt.Println("生成随机数99共使用次数 =", count)
    }

输出结果如下图所示：

![在这里插入图片描述][20210219220201839.png_pic_center]

**(6) 输入如下4\*5的矩阵。**

代码如下：

package main
    import "fmt"
     
    func main() { 
    	var n int = 4
    	var m int = 5
    	var res int = 0
    	for i := 1; i <= n; i++ { 
    		for j := 1; j <= m; j++ { 
    			fmt.Printf("%v\t", i*j)
    			res++
    		}
    		fmt.Println("")
    	} 
    }

输出结果如下图所示：

![在这里插入图片描述][20210219221752864.png_pic_center]

**(7) 利用循环求Fibonacci数列的前10个数。**

*  该函数的特点是第1、2两个数为1，从第3个数开始为前两个数的和。

![在这里插入图片描述][20210219222323687.png_pic_center]

解题思路对应的流程如下图所示：

![在这里插入图片描述][20210219222623942.png_pic_center]

package main
    import "fmt"
     
    func main() { 
    	//Fibonacci数列
    	var f1 int = 1
    	var f2 int = 1
    	var f3 int
    
    	fmt.Printf("%v\n%v\n", f1, f2)
    	for i := 1; i <= 10; i++ { 
    		f3 = f1 + f2
    		fmt.Printf("%v\n", f3)
    		f1 = f2
    		f2 = f3
    	} 
    }

输出结果如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 18]

**(8) 求2到200间的全部素数。**

*  解题思路：输入n，如果n不能被用2到sqrt(n)或2到n/2间的任一整数整除，则是素数。当然，2到(n-1)整除是最原始的方法。对应的算法流程如下：

![在这里插入图片描述][2021021922343452.png_pic_center]

代码如下：

package main
    import "fmt"
     
    func main() { 
    	//求2到200间的全部素数
    	var n int
    	var k int
    	var i int
    	var m int = 0
    
    	for n = 2; n <= 200; n++ { 
    		k = n / 2
    		//如果n被i整除终止内循环
    		for i = 2; i <= k; i++ { 
    			if n % i == 0 { 
    				break
    			}
    		}
    		//如果i>k+1表示n未被整除
    		if i >= k + 1 { 
    			fmt.Printf("%d\t", n)
    			//m控制换行 输出10个素数换行
    			m = m + 1
    			if m % 10 == 0 { 
    				fmt.Println()
    			}
    		}
    	}
    }

运行结果如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 19]

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

# 七.总结 #

写到这里，这篇基础性Golang文章介绍完毕，希望您喜欢！祝大家新年快乐，牛气冲天，也希望自己能分享更优秀、更深入的文章。

*  **一.for循环控制**  
    1.基本语法  
    2.for-range循环  
    3.for编程经典案例  
    4.类似while和do-while循环
 *  **二.多重循环控制**  
    案例1：循环计算平均成绩  
    案例2：循环打印金字塔和倒三角
 *  **三.跳转控制语句**  
    1.break  
    2.continue
 *  **四.goto语句**
 *  **五.跳转控制语句return**
 *  **六.Golang编程练习**  
    1.题目  
    2.解答

Go基本运算和进制转换了解后，后面的文章将详细介绍Go语言的条件语句和循环语句知识，并结合案例进行普及。希望这篇基础性文章对您有帮助，写得不好的地方还请海涵。同时非常感谢参考文献中的大佬们的文章分享，尤其是韩顺平老师，深知自己很菜，得努力前行。也希望自己能深入下去，未来四年好好研究Go编程语言，做更多实际工程，写更好的文章，共勉！

源代码下载地址：

*  [https://github.com/eastmountyxz/Go-learning][https_github.com_eastmountyxz_Go-learning]

2020年在github的绿瓷砖终于贴完了第一年提交2100余次，获得1500多+stars，开源93个仓库，300个粉丝。挺开心的，希望自己能坚持在github打卡五年，督促自己不断前行。简单总结下，最满意的资源是YQ爆发时，去年2月分享的舆情分析和情感分析，用这系列有温度的代码为武汉加油；最高赞的是Python图像识别系列，也获得了第一位来自国外开发者的贡献补充；最花时间的是Wannacry逆向系列，花了我两月逆向分析，几乎成为了全网最详细的该蠕虫分析；还有AI系列、知识图谱实战、CVE复现、APT报告等等。当然也存在很多不足之处，希望来年分享更高质量的资源，也希望能将安全和AI顶会论文系列总结进来，真诚的希望它们能帮助到大家，感恩有你，一起加油~

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 20]

2020年8月18新开的“娜璋AI安全之家”，主要围绕Python大数据分析、网络空间安全、人工智能、Web渗透及攻防技术进行讲解，同时分享论文的算法实现。娜璋之家会更加系统，并重构作者的所有文章，从零讲解Python和安全，写了近十年文章，真心想把自己所学所感所做分享出来，还请各位多多指教，真诚邀请您的关注！谢谢。

![在这里插入图片描述][20210129020034946.png_pic_center]

(By:娜璋AI之家 Eastmount 2021-02-19 星期五 夜于贵阳 [https://blog.csdn.net/Eastmount][https_blog.csdn.net_Eastmount])

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

**参考文献：**

*  Go官网：[https://golang.org/][https_golang.org]
 *  韩老师视频：[https://www.bilibili.com/video/BV1pt41127FZ][https_www.bilibili.com_video_BV1pt41127FZ]
 *  [https://www.runoob.com/go/go-tutorial.html][https_www.runoob.com_go_go-tutorial.html]
 *  Go中文网在线标准库文档：[https://studygolang.com/pkgdoc][https_studygolang.com_pkgdoc]
 *  《C程序设计》谭浩强老师
 *  《GO高级编程》
 *  [https://www.runoob.com/go/go-range.html][https_www.runoob.com_go_go-range.html]

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221024/4c7467d126a046d6841205a45dce15fd.png
[https_github.com_eastmountyxz_Go-learning]: https://github.com/eastmountyxz/Go-learning
[GO_ _._Golang_GO]: https://blog.csdn.net/Eastmount/article/details/111150449
[GO_ _._API]: https://blog.csdn.net/Eastmount/article/details/113151363
[GO_ _._12]: https://blog.csdn.net/Eastmount/article/details/113399802
[GO_ _.]: https://blog.csdn.net/Eastmount/article/details/113661528
[GO_ _._if_else_switch]: https://blog.csdn.net/Eastmount/article/details/113804706
[GO_ _._for_break_continue_goto]: https://blog.csdn.net/Eastmount/article/details/113826055
[20210218003139798.png_pic_center]: /images/20221024/14e696f8487f41ddb8505007fc28ed52.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221024/dc47cd0c8b2043af8714b7855d3b3a89.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221024/a2ed68b21cfc4235bf4968fc7ecf8da4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221024/762b8017d10b4b2eb03052307b831fe8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221024/e1a2c692bc1b49aeaa1cbf9da35139e8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221024/5a06fc1590464753a8fc34896a075f42.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221024/bbeb24cb71a245a0b9ab5713604f420c.png
[20210218215721713.png_pic_center]: /images/20221024/14f3707c2d8b47d48e917b6ca84d4fb7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221024/05de8fb3222f4e8585f8dbebf31b34ca.png
[20210219003709369.png_pic_center]: /images/20221024/95534f2a16d347e58299f73b8e89aff3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221024/c84d28f3af8440558d5c0ff89f431d4f.png
[20210219004747615.png_pic_center]: /images/20221024/93ffa7e27a2441d99015fdcc8bc6df46.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221024/64f29d08044343afacde8eee00d05359.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221024/02a9a245e89d43268c103fd198ff56dc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221024/49b3be18cda14923985b30174790d888.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20221024/f5eb2b6b74f74accb92f0a0fcb14541c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20221024/f6ab97b0a1a44691b5ae078f25fcc96a.png
[20210219180858130.png_pic_center]: /images/20221024/e5207dd0d4d7483282d8e6c2afc1c302.png
[2021021918183682.png_pic_center]: /images/20221024/9c3f1c6d499c46fa86e012db4a41ac83.png
[20210219182049140.png_pic_center]: /images/20221024/d4329e5d44a24b16a2120647f2d23c99.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 14]: /images/20221024/258c8945d90c4c40b459d35d7a33c06e.png
[20210219182800528.png_pic_center]: /images/20221024/89ab2327b471447f80f8dd30d6ae24d9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 15]: /images/20221024/7bc9f4a46f824c69851db85b46558639.png
[20210219192143475.png_pic_center]: /images/20221024/0f136eb7d06a4cf389a3e54296d7773d.png
[20210219193002210.png_pic_center]: /images/20221024/a4d3edad734449e2885028574298f11d.png
[20210219222323687.png_pic_center]: /images/20221024/4f08363d510549bb95cf9825b7c14fcd.png
[20210219201722261.png_pic_center]: /images/20221024/423d9c3e742048a5a264c5d72f599650.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 16]: /images/20221024/e9aa2623e82f45ef8dc824d855b93e66.png
[20210219213117143.png_pic_center]: /images/20221024/62ab9309afe541a9ba6c1b8a72b9ad71.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 17]: /images/20221024/359a99e331e0435099ee41edc540996e.png
[20210219220201839.png_pic_center]: /images/20221024/fad106883f30424a8772b778302614f2.png
[20210219221752864.png_pic_center]: /images/20221024/2fe7c77c032f48e489f6ac94ca77d00f.png
[20210219222623942.png_pic_center]: /images/20221024/79c1ec32ab6846f0ae2ddd27e161c4f5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 18]: /images/20221024/bc7ab11b3fff41ac818ee8426f745d0e.png
[2021021922343452.png_pic_center]: /images/20221024/834cf44849274adbbbfaf6c603856e88.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 19]: /images/20221024/a6cc36e0a65b435aadd31161b7a1c9da.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vhc3Rtb3VudA_size_16_color_FFFFFF_t_70_pic_center 20]: /images/20221024/fade235550414dc4ab15bb85bb4a89cc.png
[20210129020034946.png_pic_center]: /images/20221024/8764d17bb01a41eab22c2f9bba42f1bb.png
[https_blog.csdn.net_Eastmount]: https://blog.csdn.net/Eastmount
[https_golang.org]: https://golang.org/
[https_www.bilibili.com_video_BV1pt41127FZ]: https://www.bilibili.com/video/BV1pt41127FZ
[https_www.runoob.com_go_go-tutorial.html]: https://www.runoob.com/go/go-tutorial.html
[https_studygolang.com_pkgdoc]: https://studygolang.com/pkgdoc
[https_www.runoob.com_go_go-range.html]: https://www.runoob.com/go/go-range.html