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

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

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

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

在这里插入图片描述

源码下载地址：

  • https://github.com/eastmountyxz/Go-learning

前文参考：

  • [GO语言基础] 一.为什么我要学习Golang以及GO语言入门普及
  • [GO语言基础] 二.编译运行、语法规范、注释转义及API标准库知识普及
  • [GO语言基础] 三.变量声明、数据类型、标识符及编程练习12题
  • [GO语言基础] 四.算术运算、逻辑运算、赋值运算、位运算及编程练习
  • [GO语言基础] 五.顺序控制语句和条件控制语句（if、else、switch）
  • [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循环的语法格式：

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

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

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

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

在这里插入图片描述

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

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

下面举个简单的例子：

  1. package main
  2. import "fmt"
  4. func main() { 
  5.     //for循环
  6.     for n := 1; n <= 10; n++ { 
  7.         fmt.Println("Eastmount", n)
  8.     }
  9. }

输出结果如下图所示：

在这里插入图片描述

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

  1. for 循环判断条件 { 
  2.     //循环执行语句
  3. }

案例如下所示：

在这里插入图片描述

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

  1. for { 
  2.     //循环执行语句
  3. }

案例如下所示：

在这里插入图片描述

2.for-range循环

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

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

具体案例如下所示：

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

输出结果如下图所示：

在这里插入图片描述

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

rune
golang中string底层是通过byte数组实现的。中文字符在unicode下占2个字节，在utf-8编码下占3个字节，而golang默认编码正好是utf-8。rune 等同于int32，常用来处理unicode或utf-8字符。

在这里插入图片描述

下面展示具体的代码。

  1. package main
  2. import "fmt"
  4. func main() { 
  5.     //1.字符串遍历-传统方法
  6.     str := "CSDN!秀璋"
  7.     str2 := []rune(str)           //将str转换成[]rune
  8.     for i := 0; i < len(str2); i++  {   
  9.         fmt.Printf("index=%d, value=%c \n", i, str2[i])
  10.     }
  11.     fmt.Println("")
  13.     //2.字符串遍历-for range
  14.     for index, val := range str { 
  15.         fmt.Printf("index=%d, value=%c \n", index, val)
  16.     }
  17.     fmt.Println("")
  19.     //3.如果不转rune直接遍历(乱码)
  20.     for i := 0; i < len(str); i++  {   
  21.         fmt.Printf("index=%d, value=%c \n", i, str[i])
  22.     }
  23. }

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

在这里插入图片描述

3.for编程经典案例

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

  1. package main
  2. import "fmt"
  4. func main() { 
  5.     var result = 0
  6.     var num = 0
  7.     for i := 1; i <= 100; i++ { 
  8.         result += i
  9.         num++
  10.     }
  11.     fmt.Println("1+2+...+100 =", result)
  12.     fmt.Println("个数 =", num)
  13. }

输出结果如下图所示：

在这里插入图片描述

流程图如下图所示：

在这里插入图片描述

4.类似while和do-while循环

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

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

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

在这里插入图片描述

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

  1. int i = 0;
  2. while(i<10){     // notice there is only <
  3.     do something
  4. }

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

  1. package main
  2. import "fmt"
  4. func main() { 
  5.     //类似while循环
  6.     var i int = 1
  7.     for { 
  8.         //循环条件
  9.         if i > 10 { 
  10.             break           //结束循环
  11.         }
  12.         fmt.Println("hello world", i)
  13.         i++
  14.     }
  15. }

输出结果如下图所示：

在这里插入图片描述

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

在这里插入图片描述

需要注意：

  • 由于do-while是先执行后判断，因此至少执行一次

  • 当循环条件成立后，就会执行break跳出for循环

    package main
    import “fmt”

    func main() { 

    1. //使用do-while实现输出10句"hello world"
    2. var j int = 1
    3. for { 
    4.     //先执行后判断
    5.     fmt.Println("hello world", j)
    6.     j++
    7.     if j > 10 { 
    8.         break           //结束循环
    9.     }
    10. }

    }

二.多重循环控制

具体含义为：

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

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

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

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

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

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

    package main
    import “fmt”

    func main() { 

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

    }

输出结果如下图所示：

在这里插入图片描述

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

  • var classNum int = 3

  • var stuNum int = 4

    package main
    import “fmt”

    func main() { 

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

    }

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

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

在这里插入图片描述

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

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

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

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

  1. package main
  2. import "fmt"
  4. func main() { 
  5.     var totalLevel int = 5
  7.     //1.打印矩形
  8.     for i := 1; i <= totalLevel; i++ {      //i表示层数
  9.         for j := 1; j <= totalLevel; j++ {  //每层输出
  10.             fmt.Print("*")
  11.         }
  12.         fmt.Println()  //换行
  13.     }
  14.     fmt.Println()
  16.     //2.打印正三角半个金字塔
  17.     for i := 1; i <= totalLevel; i++ {    //i表示层数
  18.         for j := 1; j <= i; j++ {         //每层输出
  19.             fmt.Print("*")
  20.         }
  21.         fmt.Println()  //换行
  22.     }
  23.     fmt.Println()
  25.     //3.打印倒三角半个金字塔
  26.     for i := 1; i <= totalLevel; i++ {    //i表示层数
  27.         for j := (totalLevel - i); j >= 0; j-- {        //每层输出
  28.             fmt.Print("*")
  29.         }
  30.         fmt.Println()  //换行
  31.     }
  32. }

输出结果如下图所示：

在这里插入图片描述

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

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

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

  1. package main
  2. import "fmt"
  4. func main() { 
  5.     /* 打印金字塔 * 1层 1个* 规律: 2*层数-1 空格 4个 规律:总层数-当前层数 *** 2层 3个* 规律: 2*层数-1 空格 3个 规律:总层数-当前层数 ***** ******* ********* */
  7.     var totalLevel int = 5
  9.     //方法一 打印实心金字塔
  10.     for i := 1; i <= totalLevel; i++ {                //i表示层数
  11.         //先打印空格
  12.         for j := (totalLevel - i); j >= 0; j-- { 
  13.             fmt.Print(" ")
  14.         }
  15.         //打印星号
  16.         for k := (2 * i - 1); k > 0; k-- {      
  17.             fmt.Print("*")
  18.         }
  19.         fmt.Println()  //换行
  20.     }
  21.     fmt.Println()
  23.     //方法二 打印空心金字塔
  24.     for i := 1; i <= totalLevel; i++ {                //i表示层数
  25.         //先打印空格
  26.         for j := 1; j <= (totalLevel - i); j++ { 
  27.             fmt.Print(" ")
  28.         }
  29.         //打印星号
  30.         for k := 1; k <= (2 * i - 1); k++ { 
  31.             //每层第一个和最后一个打印* 最底层全部打印*
  32.             if k == 1 || k == (2 * i - 1) || i == totalLevel { 
  33.                 fmt.Print("*")
  34.             } else { 
  35.                 fmt.Print(" ")
  36.             }
  37.         }
  38.         fmt.Println()  //换行
  39.     }
  40. }

输出结果如下图所示：

在这里插入图片描述

三.跳转控制语句

1.break

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

  1. { 
  2.     ....
  3.     break
  4.     ....
  5. }

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

在这里插入图片描述

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

  1. package main
  2. import "fmt"
  4. func main() { 
  5.     //求出当和第一次大于20的当前数字
  6.     sum := 0
  7.     for i := 1; i <= 100; i++ { 
  8.         sum += i   //求和
  9.         if sum > 20 { 
  10.             fmt.Println("sum大于20时当前数字是", i)
  11.             break  //跳出循环
  12.         } 
  13.     }
  14. }

输出结果如下图所示：

在这里插入图片描述

break语句的注意事项：

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

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

  1. package main
  2. import "fmt"
  4. func main() { 
  5.     //通过标签跳出for循环指定层
  6.     label1:
  7.     for i := 0; i < 4; i++ { 
  8.         //label2:
  9.         for j := 0; j < 10; j++ { 
  10.             if j ==2 { 
  11.                 //默认跳出最近的循环 这里尝试跳出外层循环
  12.                 break label1
  13.             }
  14.             fmt.Println("j =", j, "i =", i)
  15.         }
  16.     } 
  17. }

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

在这里插入图片描述

2.continue

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

  1. { 
  2.     ...
  3.     continue
  4.     ...
  5. }

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

在这里插入图片描述

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

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

举个简单案例：

  1. package main
  2. import "fmt"
  4. func main() { 
  5.     //continue跳出当前循环
  6.     for i := 0; i < 4; i++ { 
  7.         for j := 0; j < 10; j++ { 
  8.             if j ==2 { 
  9.                 continue
  10.             }
  11.             fmt.Println("j =", j, "i =", i)
  12.         }
  13.     } 
  14. }

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

在这里插入图片描述

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

在这里插入图片描述

四.goto语句

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

  1. goto label
  2. ....
  3. label: statement

其执行流程如下图所示：

在这里插入图片描述

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

  1. package main
  2. import "fmt"
  4. func main() { 
  5.     //goto语句
  6.     fmt.Println("aaaaa")
  7.     var n int = 30
  8.     if n > 20 { 
  9.         goto label
  10.     }
  11.     fmt.Println("bbbbb")
  12.     fmt.Println("ccccc")
  13.     label:
  14.     fmt.Println("ddddd")
  15.     fmt.Println("eeeee")
  16.     fmt.Println("fffff")
  17. }

输出结果如下图所示：

在这里插入图片描述

五.跳转控制语句return

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

return使用说明：

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

  • 如果return是在main函数，表示终止main函数，也就是终止程序。

    package main
    import “fmt”

    func main() { 

    1. //return语句
    2. for i := 1; i<=10; i++ { 
    3.     if i==3 { 
    4.         return
    5.     }
    6.     fmt.Println("输出结果", i)
    7. }
    8. fmt.Println("over")

    }

输出结果如下图所示：

在这里插入图片描述

六.Golang编程练习

1.题目

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

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

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

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

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

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

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

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

在这里插入图片描述

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

2.解答

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

代码如下：

  1. package main
  2. import "fmt"
  4. func main() { 
  5.     var max int = 100
  6.     var count int = 0
  7.     var sum int = 0
  8.     for i := 1; i <= max; i++ { 
  9.         if i % 9 == 0 { 
  10.             count++
  11.             sum += i
  12.         }
  13.     }
  14.     fmt.Printf("count=%v sum=%v \n", count, sum)
  15. }

输出结果如下图所示：

在这里插入图片描述

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

  1. package main
  2. import "fmt"
  4. func main() { 
  5.     str := "East=秀璋"
  7.     //方法1
  8.     fmt.Printf("utf-8遍历字符串\n")
  9.     for _, s := range str { 
  10.         fmt.Printf("utf-8遍历: %c %v \n", s, s)
  11.     }
  12.     fmt.Println("")
  14.     //方法2
  15.     str2 := []rune(str)
  16.     for i := 0; i < len(str2); i++  {   
  17.         fmt.Printf("utf-8遍历: index=%d, value=%c \n", i, str2[i])
  18.     }
  19.     fmt.Println("")
  21.     //方法3 乱码
  22.     fmt.Printf("unicode遍历字符串\n")
  23.     for i := 0; i < len(str); i++ { 
  24.         ch := str[i]
  25.         fmt.Printf("unicode遍历: %c %d\n", ch, ch)
  26.     }
  27. }

输出结果如下图所示：

在这里插入图片描述

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

代码如下：

  1. package main
  2. import "fmt"
  4. func main() { 
  5.     //9*9乘法表
  6.     var num int = 9
  7.     for i := 1; i <= num; i++ { 
  8.         for j := 1; j <= i; j++ { 
  9.             fmt.Printf("%v*%v=%v \t", j, i, j*i)
  10.         }
  11.         fmt.Println()
  12.     }
  13. }

输出结果如下图所示：

在这里插入图片描述

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

代码如下：

  1. package main
  2. import "fmt"
  4. func main() { 
  5.     //模拟网站登录
  6.     var name string
  7.     var pwd string
  8.     var loginChance = 3
  10.     for i := 1; i <= 3; i++ { 
  11.         //输入信息
  12.         fmt.Println("请输入用户名")
  13.         fmt.Scanln(&name)
  14.         fmt.Println("请输入密码")
  15.         fmt.Scanln(&pwd)
  17.         if name == "Eastmount" && pwd == "666666" { 
  18.             fmt.Println("恭喜你登录成功")
  19.             break
  20.         } else { 
  21.             loginChance--
  22.             fmt.Printf("输入错误，你还有%v次机会\n", loginChance)
  23.         }
  24.     }
  25.     if loginChance <= 0 { 
  26.         fmt.Println("输入错误次数过多，无法登录")
  27.     }
  28. }

输出结果如下图所示：

在这里插入图片描述

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

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

    package main
    import (

    1. "fmt"
    2. "math/rand"
    3. "time"

    )

    func main() { 

    1. //随机生成1到100的一个数，如果生成99这个数就停止
    2. var count int = 0
    3. for { 
    4.     //种子生成 使用系统时间的不确定性来进行初始化
    5.     rand.Seed(time.Now().UnixNano())
    6.     num := rand.Intn(100) + 1
    7.     fmt.Println("num =", num)
    8.     count++
    9.     if (num == 99) { 
    10.         break
    11.     }
    12. }
    13. fmt.Println("生成随机数99共使用次数 =", count)

    }

输出结果如下图所示：

在这里插入图片描述

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

代码如下：

  1. package main
  2. import "fmt"
  4. func main() { 
  5.     var n int = 4
  6.     var m int = 5
  7.     var res int = 0
  8.     for i := 1; i <= n; i++ { 
  9.         for j := 1; j <= m; j++ { 
  10.             fmt.Printf("%v\t", i*j)
  11.             res++
  12.         }
  13.         fmt.Println("")
  14.     } 
  15. }

输出结果如下图所示：

在这里插入图片描述

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

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

在这里插入图片描述

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

在这里插入图片描述

  1. package main
  2. import "fmt"
  4. func main() { 
  5.     //Fibonacci数列
  6.     var f1 int = 1
  7.     var f2 int = 1
  8.     var f3 int
  10.     fmt.Printf("%v\n%v\n", f1, f2)
  11.     for i := 1; i <= 10; i++ { 
  12.         f3 = f1 + f2
  13.         fmt.Printf("%v\n", f3)
  14.         f1 = f2
  15.         f2 = f3
  16.     } 
  17. }

输出结果如下图所示：

在这里插入图片描述

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

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

在这里插入图片描述

代码如下：

  1. package main
  2. import "fmt"
  4. func main() { 
  5.     //求2到200间的全部素数
  6.     var n int
  7.     var k int
  8.     var i int
  9.     var m int = 0
  11.     for n = 2; n <= 200; n++ { 
  12.         k = n / 2
  13.         //如果n被i整除终止内循环
  14.         for i = 2; i <= k; i++ { 
  15.             if n % i == 0 { 
  16.                 break
  17.             }
  18.         }
  19.         //如果i>k+1表示n未被整除
  20.         if i >= k + 1 { 
  21.             fmt.Printf("%d\t", n)
  22.             //m控制换行 输出10个素数换行
  23.             m = m + 1
  24.             if m % 10 == 0 { 
  25.                 fmt.Println()
  26.             }
  27.         }
  28.     }
  29. }

运行结果如下图所示：

在这里插入图片描述

七.总结

写到这里，这篇基础性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

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

在这里插入图片描述

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

在这里插入图片描述

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

参考文献：

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

发表评论

表情：
评论列表 （有 0 条评论，279人围观）

还没有评论，来说两句吧...

相关阅读