go 流程控制语句

条件

go 中的条件 if 语句：

1. 标准写法

   score := 54
   if score >= 85 {
   	fmt.Println("优秀")
   } else if score >= 60 {
   	fmt.Println("及格")
   } else {
   	fmt.Println("不及格")
   }
   
   输出：不及格
   

2. 高级写法 带表达式

   if score := 88; score > 60 {
   	fmt.Println("及格")
   }
   
   
   输出：及格
   

switch

switch 默认不用使用 break,   匹配到条件之后 只会执行对于的语句; 如果需要 匹配到多个条件 需要使用 fallthrough

1. 标准写法

   func choose() {
   	level := "AA"
   	switch level {
   	case "A":
   		fmt.Println("优秀")
   	case "B":
   		fmt.Println("良好")
   	case "C":
   		fmt.Println("及格")
   	case "D":
   		fmt.Println("不及格")
   	default:
   		fmt.Println("缺考")
   	}
   }
   
   
   输出：缺考
   

2. 高级写法  带表达式

   func choose1() {
   	switch level := "AA"; level {
   	case "A":
   		fmt.Println("优秀")
   	case "B":
   		fmt.Println("良好")
   	case "C":
   		fmt.Println("及格")
   	case "D":
   		fmt.Println("不及格")
   	default:
   		fmt.Println("缺考")
   	}
   }
   
   
   输出： 缺考

3. 无表达式 switch, 类似于 条件语句

   func choose2() {
   	score := 80
   	switch {
   	case score > 90 && score < 100:
   		fmt.Println("优秀")
   	case score >= 60 && score <= 90:
   		fmt.Println("及格")
   	case score < 60 && score >= 0:
   		fmt.Println("不及格")
   	}
   }
   
   
   输出：及格

4. fallthrough 多条件执行

   //****** go 语言中 switch 默认只匹配条件成立的（不需要写 break）；如果想要匹配多条件需要使用 fallthrough
   func choose3() {
   	str := "我想玩 不想学习"
   	switch {
   	case str == "我想玩 不想学习":
   		fmt.Println("优秀")
   		fallthrough
   	case str == "我想学， 但是我也想玩":
   		fmt.Println("及格")
   
   	case str == "我想学， 不想玩":
   		fmt.Println("不及格")
   
   	case str != "我想学， 不想玩":
   		fmt.Println("你可以直接上天")
   
   	}
   }
   
   
   多条件匹配 输出两个：
   优秀
   及格

循环 

go语言中 循环只有 for；  没有 while， do while

1. 单条件 表达式

   // 1 单条件 表达式
   count := 5
   for count > 0 {
   	fmt.Println(count)
   	count--
   }

2. 三个条件表达式

   // 2 三个条件表达式
   for num := 0; num < 3; num++ {
   	fmt.Println(num)
   }

3. 范围表达式

   // 3 范围表达式
   str := "赚钱 养白龙马"
   for index, ele := range str {
   	fmt.Printf("索引 ：%d, 值：%c\n", index, ele)
   }

4. 无表达式

   // 4 没有表达式， 一直循环 可以使用 依赖 break,跳出循环
   for {
   	sum++
   	if sum > 10 {
   		fmt.Println("break", sum)
   		break
   	}
   }

continue ：

//continue 的使用，条件成立 跳过当前语句，继续下一次循环
for num := 10; num > 0; num-- {
	if num == 7 || num == 9 {
		continue
	}
	fmt.Println("continue", num)
}

break ：

for num := 10; num > 0; num-- {
	if num == 7 || num == 9 {
		break
	}
}

defer 延迟

defer  在普通语句之后执行；

总结：在 普通语句 之后 reture 之前； 如果存在多个 defer  语句 按照 栈的方式 先进后出 执行

 

1. 普通语句之后 多个 defer

   func deferMethod() {
   	defer fmt.Println("延迟调用方法开始")
   	defer fmt.Println("延迟调用方法结束")
   
   	fmt.Println("在顺序后面 却最先执行")
   	fmt.Println("-------------------------------------")
   	// defer 引起的问题
   
   	str := "defer 引起的问题"
   	defer fmt.Println(str)
   	str = "我能有问题吗？"
   	fmt.Println(str)
   }
   
   输出：
   
   在顺序后面 却最先执行
   -------------------------------------
   我能有问题吗？
   defer 引起的问题
   延迟调用方法结束
   延迟调用方法开始
   

2. defer  reture 

   var info string = "defer 特性 讲解0000"
   
   //go 延迟 defer 不是原子性，先执行返回  再执行defer
   func showInfo() string {
   	defer func() {
   		info = "defer 特性 讲解1111"
   	}()
   	fmt.Println("showInfo info:", info)
   	return info
   }
   
   func deferMethod3() {
   
   	deInfo := showInfo()
   	fmt.Println("info :", info)
   	fmt.Println("deInfo :", deInfo)
   
   }
   
   输入：
   
   showInfo info: defer 特性 讲解0000
   deInfo : defer 特性 讲解0000
   info : defer 特性 讲解1111
   
   

3. defer 在 结构体 中的顺序

   type Person struct {
   	name, nickName, icon string
   }
   func (p Person) printName() {
   	fmt.Println("Person Name", p.name)
   }
   
   func deferMethod2() {
   
   	//defer 栈
   	//多个 defer 语句 从最后一个开始执行   先进后出
   
   	person := Person{
   		name:     "王大锤",
   		nickName: "王二锤",
   		icon:     "https://a.png",
   	}
   	defer person.printName()
   	fmt.Println("deferMethod2")
   	defer fmt.Println("0基础学习 GO")
   
   }
   
   
   输出：
   
   deferMethod2
   0基础学习 GO
   Person Name 王大锤
   

goto 跳转

跳过某些代码块;  其中goto 关键字和 需要跳转的位置之间 不能存在变量的声明

 

func gotoExample() {
	fmt.Println("从0开始学Go")
	name := "4444"
	goto label
	fmt.Println("从1开始学Go", name)
	fmt.Println("从1开始学Go", name+"4555")
	name = "555"
	//  age := 16   不可以声明 编译错误
	if name == "4444" {
		fmt.Println("goto 关键字和 需要跳转的位置之间  不能存在变量的声明")
	}
label:
	fmt.Println("从lable开始学Go")
}


输出：

从0开始学Go
从lable开始学Go