三大流程控制语句

1. 顺序控制程序从上到下逐行进行，中间没有任何判断和跳转，因为程序按照默认的流程执行，即顺序控制。
2. 分支控制分支控制就是让程序有选择地执行，有单分支（if）、双分支（if_else）、多分支（if_else if _else）。
3. 循环控制

If_else

示例代码：

 func main() {
     var a, b, c int32
     fmt.Println("请输入")
     fmt.Scanln(&a, &b)
     c = a + b
     if c%3 == 0 && c%5 == 0 {
         fmt.Println("可以整除")
     } else {
         fmt.Println("不能整除")
     }
 }

注意事项：

1. 这里即使只有一条语句，这里也必须要有大括号
2. if_else必须写成 if{
        
    } else {
        
    }else不能够换行

上个小案例，就用最简单的二元一次方程组根的判断吧

 package main
 ​
 import (
     "fmt"
     "math"
 )
 ​
 func main() {
     var a, b, c float64
     var an1, an2 float64
     fmt.Scanf("%f,%f,%f", &a, &b, &c)
     an1 = (b + math.Sqrt(b*b-4*a*c)) / (2 * a)
     an2 = (-b + math.Sqrt(b*b-4*a*c)) / (2 * a)
     if (b*b - 4*a*c) > 0 {
         fmt.Printf("结果为x1=%v x2 = %v", an1, an2)
     } else if (b*b - 4*a*c) == 0 {
         fmt.Printf("结果为x1=x2 = %v", an1)
     } else {
         fmt.Printf("无实数根")
     }
 }
 ​

当然在实际的开发过程中，我们可能会遇到更复杂的多个条件，那么我们就可以用多个if来嵌套使用，比如这样一个出票系统：根据淡旺季的月份和年龄，打印票价

4_10 月 旺季：

• 成人（18-60）：60
• 儿童（<18）: 半价
• 老人（>60）: 1/3

淡季：

• 成人：40
• 其他：20

 package main
 ​
 import "fmt"
 ​
 func main() {
     var mouth, age int
     fmt.Println("请输入月份")
     fmt.Scanln(&mouth)
     fmt.Println("请输入年龄")
     fmt.Scanln(&age)
     if mouth > 4 && mouth < 10 {
         if age < 0 || age > 150 {
             fmt.Println("输入错误，请重新输入年龄")
         }
         if age > 60 {
             fmt.Println("票价为20")
         } else if age < 18 {
             fmt.Println("票价为30")
         } else {
             fmt.Println("票价为60")
         }
     } else {
         if age < 0 || age > 150 {
             fmt.Println("输入错误，请重新输入年龄")
         }
         if age > 60 {
             fmt.Println("票价为20")
         } else if age < 18 {
             fmt.Println("票价为20")
         } else {
             fmt.Println("票价为40")
         }
     }
 }
 ​

当然这里为了可以展示嵌套，代码有些冗余，相信大家都会有更简洁的写法。

switch

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

匹配项后面不需要加break（和传统的编程语言很不同的一个点哦）

语法：

 switch 表达式 {
 case 表达式1, 表达式2, ...:
     语句块1
 ​
 case 表达式3, 表达式4, ...:
     语句块2
 //这里可以有多个case语句
 ​
 default:
     语句块
 }

我们可以发现和传统编程语言又一个不同的点，就是这里可以对应多个值。

注意：

1. case后面是一个表达式（即：常量变量，一个有返回值的函数都可以）
2. case后的各个表达式的值的数据类型，必须和switch的表达式数据类型一致
3. case后面的表达式如果是常量值则要求不能重复
4. default不是必须的
5. switch可以后面不带表达式类似于if_else来使用
6. case可以对范围进行判断（case score > 80）
7. switch后面可以直接声明定义一个变量，分号结束，但是不推荐
8. type-switch来判断某个interface变量中实际指向的变量类型

for

一键入门

 for i := 1; i <= 10; i++{
     fmt.Println("三角洲启动")
 }

注意：

1. 循环条件是一个返回布尔值的比倒是
2. for循环 的第二种使用方式 for 循环判断条件 {
     //循环语句
    }

变量初始化和变量迭代写到其他位置

3. 第三种写法 for {
     //循环语句
    }等价于for;;{}是一个无限循环，通常搭配break使用
4. 提供for-range的方式可以方便的遍历字符串和数组

 func main() {
     str := "航天桥是我的家乡"
     for index, val := range str {
         fmt.Printf("value=%d, val=%c\n", index, val)
     }
 }
 ​

这里字符串含有中文，如果我们用传统的字符串遍历方法来看一看

 package main
 ​
 import "fmt"
 ​
 func main() {
     str := "航天桥是我的家乡"
     for i := 1; i < len(str); i++ {
         fmt.Printf("%c\n", str[i])
     }
 }
 ​

我们会发现这里出现了乱码

原因分析：

传统的字符串的遍历按照字节遍历，但是一个汉字的utf-8编码中一个汉字对应三个字节。

解决方法

将数组转化为rune切片

 package main
 ​
 import "fmt"
 ​
 func main() {
     str := "航天桥是我的家乡"
     str2 := []rune(str)
     for i := 0; i < len(str2); i++ {
         fmt.Printf("%c\n", str2[i])
     }
 }

案例：

1.任意输入一个数，打印出1~100之间所有是这个数的倍数的证书的个数以及总和 package main

 ​
 import "fmt"
 ​
 func main() {
  var num, total, time int
  fmt.Scanln(&num)
  for i := 0; i < 101; i++ {
  if i%num == 0 {
  time++
  total += i
  }
  }
  fmt.Printf("总和为：%d, 个数为：%d", total, time)
 }

2.以a+b=c的形式打印出输入变量c的所有可能表达式

 package main
 ​
 import "fmt"
 ​
 func main() {
     var result int
     fmt.Println("请输入结果值")
     fmt.Scanln(&result)
     for a := 0; a <= result; a++ {
         for b := 0; b <= result; b++ {
             if a+b == result {
                 fmt.Printf("%d + %d = %d\n", a, b, result)
             }
         }
     }
 }
 ​

多层循环嵌套

在上面的案例中就用到了这样的思想，将一个循环放到另一个循环体内，外面的for就是外层循环，内层的for就是内层循环，循环嵌套就是把内层循环当成外层循环的循环体，我们就来用经典的空心金字塔案例来感受一下

 package main
 ​
 import "fmt"
 ​
 func main() {
     var totalLevel int = 20
 ​
     // i 表示层数
     for i := 1; i <= totalLevel; i++ {
         // 在打印*前先打印空格
         for k := 1; k <= totalLevel-i; k++ {
             fmt.Print(" ")
         }
 ​
         // j 表示每层打印多少*
         for j := 1; j <= 2*i-1; j++ {
             if j == 1 || j == 2*i-1 || i == totalLevel {
                 fmt.Print("*")
             } else {
                 fmt.Print(" ")
             }
         }
         fmt.Println()
     }
 }

break

break就是跳出最近的一层循环，咱们直接上例子

随机生成一个1-100的数，直到生成了某个数字，看看尝试了多少次

这里提供一个技术文档：伪随机数

 package main
 ​
 import (
     "fmt"
     "math/rand"
 )
 ​
 func main() {
     var goal, times int
     fmt.Println("请输入目标数字：")
     fmt.Scanln(&goal)
     for {
         var num = rand.Intn(100)
         fmt.Println(num)
         if goal == num {
             break
         }
         times++
     }
     fmt.Printf("次数为：%d", times)
 }

continue

结束本次循环，继续执行下次循环

比如我们要筛选奇数

 package main
 ​
 import "fmt"
 ​
 func main() {
     for i := 1; i < 101; i++ {
         if i%2 == 0 {
             continue
         }
         fmt.Printf("%d是奇数\n", i)
     }
 }
 ​

go-to

可以无条件地转移到程序中指定的行，但是在程序设计中一般不主张使用goto语句，以免造成程序流程的混乱。

语法：

 goto label
 ​
 label:
     statement

return

使用在方法或函数中，表示跳出所在的方法或函数。