1、if

• 条件表达式左右的()是建议省略的
• if后面一定要有空格，和条件表达式分隔开来
• { }一定不能省略
• if后面可以并列的加入变量的定义

if count := 20;count < 30 {
       fmt.Println("对不起，口罩存量不足")
}

• 注意else的位置

if 条件表达式 {
   逻辑代码1
} else {
   逻辑代码2
}

• 多分支

//如果已经走了一个分支了，那么下面的分支就不会再去判断执行了
//多选一
if 条件表达式1 {
    逻辑代码1
} else if 条件表达式2 {    //隐藏&&不满足表达式1
    逻辑代码2
}
.......
else {
    逻辑代码n
}

2、switch

• switch后是一个表达式(即:常量值、变量、一个有返回值的函数等都可以)
• case后面的值如果是常量值(字面量)，则要求不能重复
• case后的各个值的数据类型，必须和 switch 的表达式数据类型一致

• case后面可以带多个值，使用逗号间隔。比如 case 值1,值2…
• case后面不需要带break
• default语句不是必须的，位置也是随意的
• switch后可以不带表达式，类似IF

• 可在switch表达式中直接定义变量，但此时必须加封号

• 可在case语句块后增加fallthrough关键字，实现穿透，只穿一层（执行下一层）

3、for

注意点：for的初始表达式中，不能用var定义变量的形式，要用:=

var sum int = 0
for i := 1 ; i <= 5 ; i++ {
        sum += i
}

格式可调整为：

func main(){
     i := 1 //变量的初始化
     for i<=5 {//条件表达式。判断条件
             fmt.Println("你好 Golang")//循环体
             i++//迭代
     }
}

死循环：

for {
     fmt.Println("你好 Golang")
}

for ;; {
     fmt.Println("你好 Golang")
}

4、for range

有点像Java的foreach，用于遍历数组、切片、字符串、map、通道

for key, val := range coll {
    ...
}

遍历coll，遍历的每个结果，索引值被key接收，值被val接收。

package main
import "fmt"
func main(){
        //定义一个字符串：
        var str string = "hello golang你好"
        //方式1：普通for循环：按照字节进行遍历输出的 （暂时先不使用中文）
        // for i := 0;i < len(str);i++ {//i:理解为字符串的下标
        // 	fmt.Printf("%c \n",str[i])
        // }
        //方式2：for range
        for i , value := range str {
                fmt.Printf("索引为：%d,具体的值为：%c \n",i,value)
        }
        //对str进行遍历，遍历的每个结果的索引值被i接收，每个结果的具体数值被value接收
        //遍历对字符进行遍历的
}

5、break

• 结束整个整个循环
• 多层循环嵌套时，结束最近的那一层
• 可以加标签去精确结束某一层循环，有点像前端的锚点

package main
import "fmt"
func main(){
        //双重循环：
        label2:
        for i := 1; i <= 5; i++ {
        		//label1:
        		//如果那个标签没有使用到 的话，那么标签不用加，否则报错：定义未使用
                for j := 2; j <= 4; j++ {
                        fmt.Printf("i: %v, j: %v \n",i,j)
                        if i == 2 && j == 2 {
                                break label2   //结束指定标签对应的循环
                        }
                }
        }
        fmt.Println("-----ok")
}

6、continue

• 结束本轮循环，不是整个循环

package main
import "fmt"
func main(){
        //功能：输出1-100中被6整除的数：
        //方式1：
        for i := 1; i <= 100; i++ {
          if i % 6 == 0 {
         	 fmt.Println(i)
          }
        }
        //方式2：
        for i := 1; i <= 100; i++ {
                if i % 6 != 0 {
                        continue //结束本次循环，继续下一次循环
                }
                fmt.Println(i)
        }
}

• 多层循环时，还是只对最近的那层循环生效
• 可以使用标签去精确操作某一层循环

package main
import "fmt"
func main(){
        //双重循环：
        label:
        for i := 1; i <= 5; i++ {
                for j := 2; j <= 4; j++ {			
                        if i == 2 && j == 2 {
                                continue label
                        }
                        fmt.Printf("i: %v, j: %v \n",i,j)
                }
        }
        fmt.Println("-----ok")
}

运行：

7、goto

• 无条件地转移到程序中指定的行
• 配合IF使用

package main
import "fmt"
func main(){
        fmt.Println("hello golang1")
        fmt.Println("hello golang2")
        if 1 == 1 {
                goto label1 //goto一般配合条件结构一起使用
        }
        fmt.Println("hello golang3")
        fmt.Println("hello golang4")
        fmt.Println("hello golang5")
        fmt.Println("hello golang6")
        label1:	//定义标签
        fmt.Println("hello golang7")
        fmt.Println("hello golang8")
        fmt.Println("hello golang9")
}

8、return

• 结束程序的运行
• 返回给调用者

package main
import "fmt"
func main(){
        for i := 1; i <= 100; i++ {
                fmt.Println(i)
                if i == 14 {
                        return //结束当前的函数
                }
        }
        fmt.Println("hello golang")
}