• Go语言循环判断的使用~

    Go 语言条件语句

    　　条件语句需要开发者通过指定一个或多个条件，并通过测试条件是否为 true 来决定是否执行指定语句，并在条件为 false 的情况在执行另外的语句。

    下图展示了程序语言中条件语句的结构：

    if 语句由布尔表达式后紧跟一个或多个语句组成。

    语法

    Go 编程语言中 if 语句的语法如下：

    if 布尔表达式 {
   // 在布尔表达式为 true 时执行 
}

    　栗子~

     1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func  main()  {
 8     //定义局部变量
 9     a := 85
10 
11     //使用go中的if判断语句
12     if a > 80 {
13         //满足判断条件，执行输出一下内容
14         fmt.Println("成绩良好~，分数为:", a)
15     }
16 }

    以上代码执行结果为：

    成绩良好~，分数为: 85

    Go 语言 if...else 语句

    if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。

    语法

    Go 编程语言中 if...else 语句的语法如下：

    if 布尔表达式 {
   //判断条件为真时候需要执行的代码块
} else {
   //判断条件为假的时候需要执行的代码块
}
    　
    栗子~
     1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func  main()  {
 8     //定义局部变量
 9     a := 30
10 
11     if a > 40{
12         //判断条件变量a的值如果大于40，则执行下面的代码块，输出大于40哦~
13         fmt.Println("大于40哦~")
14     }else {
15         //判断条件不满足大于40，则执行下面的代码块输出小于40哦~
16         fmt.Println("小于40哦~")
17     }
18     //打印变量a的值
19     fmt.Println("变量a的值为:",a)
20 }
    

    执行结果为
    

    

    小于40哦~
变量a的值为: 30
    

    


    Go 语言循环语句
    

    在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句，有些循环是有循环次数，有些事无限循环的，下面将会举例说明。
    

    语法
    

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

    和 C 语言的 for 一样：
    

    

    for 初始化变量;判断条件;修正变量{}
    

    

    和 C 的 while 一样：
    

    

    for 判断条件 {}
    

    

    无限循环(死循环)
    

    

    for { }
    

    

    for语句执行过程如下：
    

      

    1.  先对变量初始化赋值
      2. 

    2. 判断初始化的变量是否满足循环的条件，如果满足即为真，则执行循环内部的代码块，然后执行修正条件(递增++或者递减--)，然后进入第二 第三...轮循环，直到条件不满足，循环结束！
      3. 

    

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


    

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

    


    for语句语法流程如下图所示：
    

    


     栗子~
    


    

     1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 
 8 func main(){
 9     //初始化局部变量sum，用于求和的变量
10     sum := 0
11     //初始化变量i为1，判断条件为i小于等于100，修正判断条件的是每循环一次i递增+1
12     for i := 1; i<=100; i++{
13         //每一次循环都让当前的sum值加上当前循环i的值
14         sum += i
15     }
16     //循环结束以后100之内的所有正整数的和
17     fmt.Println("100之内整数的和为:", sum)
18 
19 
20     var i int = 15
21     var j int
22     //当变量j小于变量i的时候进入循环体
23     for j < i {
24         //修正循环体的条件，每循环一次j+1
25         j++
26         fmt.Println("j的值为:", j)
27     }
28 
29     //初始化局部变量l1（10位的整数型数组）
30     l1 := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
31     //循环数组
32     for index,v := range l1{
33         //打印数组每个索引位置上的元素
34         fmt.Printf("第 %d 位的元素为: %d
", index, v)
35     }
36 
37 }
    

    

    以上代码执行结果为：
    

    

    100之内整数的和为: 5050
j的值为: 1
j的值为: 2
j的值为: 3
j的值为: 4
j的值为: 5
j的值为: 6
j的值为: 7
j的值为: 8
j的值为: 9
j的值为: 10
j的值为: 11
j的值为: 12
j的值为: 13
j的值为: 14
j的值为: 15
第 0 位的元素为: 1
第 1 位的元素为: 2
第 2 位的元素为: 3
第 3 位的元素为: 4
第 4 位的元素为: 5
第 5 位的元素为: 6
第 6 位的元素为: 7
第 7 位的元素为: 8
第 8 位的元素为: 9
第 9 位的元素为: 10
    

    


    Go 语言允许用户在循环内使用循环。接下来我们将为大家介绍嵌套循环的使用。
    

    语法
    

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

    

    for [判断条件 |  ( 初始化变量; 判断条件; 修正判断条件的递增或者递减 ) | Range]
{
    for [判断条件 |  ( 初始化变量; 判断条件; 修正判断条件的递增或者递减 ) | Range]
    {
        循环中的代码块;
    }
    循环外的代码块;
}
    

    

    栗子~
    

    以下实例使用循环嵌套来输出 2 到 100 间的素数：
    

    

    

     1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func main(){
 8     //定义局部变量
 9     var  i, j int
10 
11     for i=2; i < 100; i++ {
12         for j=2; j <= (i/j); j++ {
13             if i%j == 0 {
14                 break//如果发现因子，则不是素数，退出当前的循环体
15             }
16         }
17         if j> (i/j) {
18             fmt.Printf("%d 是素数
", i)
19         }
20     }
21 
22 }
    

    

    

    以上代码执行结果为：
    

    

    2 是素数
3 是素数
5 是素数
7 是素数
11 是素数
13 是素数
17 是素数
19 是素数
23 是素数
29 是素数
31 是素数
37 是素数
41 是素数
43 是素数
47 是素数
53 是素数
59 是素数
61 是素数
67 是素数
71 是素数
73 是素数
79 是素数
83 是素数
89 是素数
97 是素数
    

    

    Go 语言 break 语句 
    

    Go 语言中 break 语句用于以下两方面：
    

      

    1. 用于循环语句中跳出循环，并开始执行循环之后的语句。
      2. 

    2. break在switch（开关语句）中在执行一条case后跳出语句的作用。
      3. 

    

    break 语句流程图如下：
    

    


    栗子~
    

    

     1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func main(){
 8     for i := 1;i<10;i++{
 9         //当i的第8次循环时候，跳出整个循环体
10         if i == 8{
11             fmt.Printf("for的第 %d 次循环，循环中遇到break退出整个循环体咯~",i)
12             //跳出整个循环体
13             break
14         }
15         fmt.Printf("for的第 %d 次循环.
",i)
16     }
17 
18 }
    

    

    以上代码执行结果为：
    

    

    for的第 1 次循环.
for的第 2 次循环.
for的第 3 次循环.
for的第 4 次循环.
for的第 5 次循环.
for的第 6 次循环.
for的第 7 次循环.
for的第 8 次循环，循环中遇到break退出整个循环体咯~
    

    


    Go 语言 continue 语句
    

    Go语言的continue语句有点像break语句。但是continue不是跳出整个for循环，而是跳过当前循环而执行下一次循环语句。
    

    for循环中，执行continue语句会触发for增量语句的执行。
    

    栗子~
    

    

     1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func main(){
 8 
 9     var sum int = 0
10     for i := 1; i<=100; i++ {
11         //当变量i和2取余数不等于0，即代表是奇数，就跳出本轮循环执行下次循环
12         if i%2 != 0 {
13             //跳过本轮循环执行下一次循环
14             continue
15         } else {
16             //当时偶数的时候，就做和的叠加
17             sum += i
18         }
19     }
20     fmt.Printf("100之内所有偶数的和为: %d", sum)
21 }
    

    

    以上代码执行结果为：
    

    

    100之内所有偶数的和为: 2550
    

    


    Go 语言 goto 语句
    

    Go 语言的 goto 语句可以无条件地转移到过程中指定的行。
    

    goto语句通常与条件语句配合使用。可用来实现条件转移， 构成循环，跳出循环体等功能。
    

    但是，在结构化程序设计中一般不主张使用goto语句， 以免造成程序流程的混乱，使理解和调试程序都产生困难。
    

    语法
    

    goto 语法格式如下：
    

    

    goto LABEL;
..
.
LABEL: 代码段;
    

    

    break 语句流程图如下：
    

    

    栗子~
    

    

     1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func main(){
 8     for i := 1; i<10; i++{
 9         //当第六次循环的时候，满足判断条件，执行goto
10         if i == 6{
11             //会直接调到后面的LABEL对应的语句，循环将不再继续
12             goto LABEL
13         }else{
14             fmt.Printf("for循环内的第%d次循环.
", i)
15         }
16     }
17     LABEL: fmt.Printf("循环到第6次咯，宝宝不要在循环了~")
18     fmt.Println("我是goto下面的语句~")
19 
20 }
    

    

    以上代码执行结果为：
    

    

    for循环内的第1次循环.
for循环内的第2次循环.
for循环内的第3次循环.
for循环内的第4次循环.
for循环内的第5次循环.
循环到第6次咯，宝宝不要在循环了~我是goto下面的语句~
    

    



    Go 语言 无限循环 语句
    

    Go 语言的 无限循环 语句，只要你计算机不挂掉，你不手动终止程序，它可以陪你到天荒地老~~
    

    栗子~
    

    

     1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func main(){
 8     //无限循环语句~~陪你到天荒地老...
 9     for {
10         fmt.Println("在那美丽的大草原，有一群草泥马，草泥马 草泥马 草泥马~~~~")
11     }
12 
13 }
    

    

    以上代码执行结果为： 
    

    

    在那美丽的大草原，有一群草泥马，草泥马 草泥马 草泥马~~~~
在那美丽的大草原，有一群草泥马，草泥马 草泥马 草泥马~~~~
在那美丽的大草原，有一群草泥马，草泥马 草泥马 草泥马~~~~
在那美丽的大草原，有一群草泥马，草泥马 草泥马 草泥马~~~~
在那美丽的大草原，有一群草泥马，草泥马 草泥马 草泥马~~~~
在那美丽的大草原，有一群草泥马，草泥马 草泥马 草泥马~~~~
................
................
................
    

    

     
    

    Go 语言 switch 语句
    

    switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上直下逐一测试，直到匹配为止。。
    

    switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加break
    

    语法
    

    Go 编程语言中 switch 语句的语法如
    


    

     1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func main(){
 8     //定义全局变量
 9     grade := "A"
10     marks := 90
11 
12     //根据局部变量marks的赋值，分别给grade二次赋值
13     switch marks {
14         case 90:
15             grade = "A"
16         case 80:
17             grade = "B"
18         case 60,70:
19             grade = "C"
20         default:
21             grade = "D"
22         }
23 
24     //根据grade的二次赋值，选择对应的输出
25     switch grade {
26         case "A":
27             fmt.Println("优秀哦~")
28         case "B":
29             fmt.Println("良好 良好~")
30         case "C":
31             fmt.Println("是不是TMD傻")
32         default:
33             fmt.Println("MD,脑袋糊浆糊了~")
34         }
35     fmt.Println("你的等级是:",grade)
36 }
    

    

    以上代码执行结果为： 
    

    

    优秀哦~
你的等级是: A
    

    


    Type Switch
    

    switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际存储的变量类型。
    

    Type Switch 语法 
    


    

    switch x.(type){
    case type:
       代码块;      
    case type:
       代码块; 
    /* 你可以定义任意个数的case */
    default: /* 可选 */
       代码块;
}
    

    

    栗子~
    

    

     1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func main() {
 8     var x interface{} = 100.123
 9 
10     //通过反射获取类型
11     switch i := x.(type) {
12         case nil:
13             fmt.Printf(" x 的类型 :%T",i)
14         case int:
15             fmt.Printf("x 是 int 型")
16         case float64:
17             fmt.Printf("x 是 float64 型")
18         case func(int) float64:
19             fmt.Printf("x 是 func(int) 型")
20         case bool, string:
21             fmt.Printf("x 是 bool 或 string 型" )
22         default:
23             fmt.Printf("未知型")
24         }
25 }
    

    

     以上代码执行结果为： 
    

    

    x 是 float64 型
    

    


    
    
          
    • 

          
  • 

            相关阅读:
    
            
              python 高阶函数
                
    python 列表
                
    python 模块
                
    浅谈HashMap原理，记录entrySet中的一些疑问
                
    extjs Tree中避免连续单击会连续请求服务器
                
    Java类的加载顺序
                
    mybatis中集成sharing-jdbc采坑
                
    tomcat采坑
                
    AQS原理
                
    Redis分布式锁原理
                
                    
          
    • 
          
  • 
            原文地址：https://www.cnblogs.com/demon89/p/7253835.html
          
    • 

        

      



      
      

        

        

      

    

  


  

  
Copyright © 2020-2023 
  润新知