1. 顺序控制
2. 分支控制
3. 循环控制

顺序控制

从上到下逐步执行

分支控制

分支控制就是让程曦有选择执行

1. 单分支
2. 双分支
3. 多分支

单分支控制

//if 条件表达式 {
//}

func main() {var age int
   fmt.Println("请输入年龄")
   fmt.Scanln(&age)

   if age>18{
      fmt.Println("成年人")}
}

双分支控制

if 条件表达式 {
    执行代码块1
}else{
    执行代码块2
}

案例：

求

ax^2+bx+c=0方程的解，a,b,c分别为函数的参数

如果：b^2-4ac>0， 则有两个解；b^2-4ac=0,则有一个解；b^2-4ac<0，则无解；

提示1：

x_1 = (-b+sqrt(b^2-4ac))/2a

x_2 = (-b-sqrt(b^2-4ac))/2a

提示2：

math.Sqrt(num)；可以求平方根，需要引入math包

测试数据：3,100,6

switch分支控制

1. go中没有bireak
2. go中的case可以有多个，用逗号间隔
3. case\switch后是一个表达式（常量，变量、有返回值的函数）
4. case后表达式的值类型必须和switch表达式值的类型一致
5. default不是必须
6. switch后也可以不带表达式，类型if-else
7. switch穿透 fallthrough，也叫switch穿透，在case后增加fallthrough，会继续执行下一个case（默认只能穿透一层）
8. switch判断变量的类型

var key byte
fmt.Scanf("%c",&key)

switch key {case 'a':fmt.Println("1")case 'b':fmt.Println("2")case 'c':fmt.Println("3")default:
       fmt.Println("0")
}

switch  test(key)+1 
case 1,2,3,4

不带表达式

//不带表达式
var age int = 10
switch  {
case age==90: fmt.Println(1)
case age==80: fmt.Println(2)
default:
   fmt.Println(0)
}

//case对范围镜像判断
Case age>10 && age<20: fmt.Println(0)

//switch后带一个声明的变量，分号结束
switch age := 10;{...
}

switch穿透

var num int =10
switch num {
case 10: fmt.Println(1)
   fallthrough
case 20: fmt.Println(2)
case 30: fmt.Println(3)
}
//10
//20

判断变量类型

var x interface{}
var y = 10.0
x = y
switch i := x.(type) {
case nil:
   fmt.Printf("%T", i)
case int:
   fmt.Printf("int")
case float64:
   fmt.Printf("float64")
case func(int) float64:
   fmt.Printf("func(int)")
case bool, string:
   fmt.Printf("bool或者string")
}
//float64

小写转大写

var s byte
fmt.Println("请输入")
fmt.Scanf("%c", &s)
switch s {
case 'a':
   fmt.Println("A")
case 'b':
   fmt.Println("B")
case 'c':
   fmt.Println("C")
case 'd':
   fmt.Println("D")
default:
   fmt.Println("other")
}

例子

//判断是否及格
var score float64
fmt.Println("请输入")
fmt.Scanln(&score)
switch int(score / 60) {
case 1:
   fmt.Println("及格")
case 0:
   fmt.Println("不及格")
default:
   fmt.Println("老实点")
}

For

语法格式

//for-demo1
for i := 0; i < 10; i++ {
   fmt.Println("测试")
}

循环变量初始化、循环条件、循环变量迭代

第二种写法

k := 1
for k <= 10 {
   fmt.Println("测试")
   k++
}

第三种写法

k := 1
for {if k <= 10 {
      fmt.Println("测试")} else {break}
   k++
}

字符串遍历range

//传统方式
var str string = "hello golang"
for i := 0; i < len(str); i++ {
   fmt.Printf("%c\n", str[i])
}

//range
var str string = "hello golang"
for k, v := range str {
   fmt.Printf("k=%d,v=%c\n", k, v)
}

但是，汉字遍历会出错，遍历是按字节来遍历，一个汉字在utf8中有3个字节

解决方案：str 转 []rune 切片,range可以直接遍历

var str string = "i am in 深圳"
str1 := []rune(str)
for i := 0; i < len(str1); i++ {
   fmt.Printf("%c\n", str1[i])
}

for k, v := range str {
   fmt.Printf("k=%d,v=%c\n", k, v)
}

例子

var max uint64 = 100
var count uint64 = 0
var sum uint64 = 0
var i uint64 = 1
for ; i <= max; i++ {if i/9 == 0 {
      count++
      sum += i
   }
}
fmt.Printf("count=%v sum=%v\n", count, sum)

while与do while的实现

多重循环

1. 内存循环完才会进入外层循环
2. 循环次数：内循环+外循环

例子：打印乘法表

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()
}

Break

中止当前for循环或者switch语句

var count int = 0
for {
   rand.Seed(time.Now().UnixNano())
   n := rand.Intn(100) + 1
   fmt.Println(n)
   count++if n == 99 {break}
}
fmt.Println(count)

1. break默认会跳出最近的一个循环，进入上一层循环
2. 在多层嵌套循环中，通过标签指明要终止的是哪一层语句

label1:for i := 0; i < 3; i++ {for j := 0; j < 12; j++ {if j == 2 {//breakbreak label1
         }
         fmt.Println(j)}}
}

continue

1. 结束本次循环，进入下一次循环
2. 可以通过标签指明要跳过的是哪一层循环

label1:for i := 0; i < 3; i++ {for j := 0; j < 5; j++ {if j == 2 {continue label1
         }
         fmt.Println(j)}}

// 01 01 01

for i := 0; i < 3; i++ {for j := 0; j < 5; j++ {if j == 2 {continue}
      fmt.Println(j)}
}
// 0,1,3,4, 0,1,3,4, 0,1,3,4

跳转控制语句goto

1. goto语句可以无条件的转移到程序中指定的行
2. goto语句通常与条件语句配合使用，可用来实现条件转移，跳出循环体等功能
3. 不主张用goto，以免导致程序流程混乱

var n int = 20
   fmt.Println(1)
   fmt.Println(2)if n > 11 {
      goto lable1
   }
   fmt.Println(3)
lable1:
   fmt.Println(4)
   fmt.Println(5)

跳出控制语句return

在方法或者函数中，表示跳出所在的方法或者函数