Golang学习（三）：流程控制

1. if-else

package main
import (
	"fmt"
	_ "math"
)

func main(){
	//岳小鹏参加Golang考试，他和父亲岳不群达成承诺：
	// 如果：
	// 成绩为100分时，奖励一辆BMW；
	// 成绩为(80，99]时，奖励一台iphone7plus；
	// 当成绩为[60,80]时，奖励一个 iPad；
	// 其它时，什么奖励也没有。
	// 请从键盘输入岳小鹏的期末成绩，并加以判断

	//分析思路
	//1. score 分数变量 int
	//2. 选择多分支流程控制
	//3. 成绩从键盘输入 fmt.Scanln

	/*
	var score int
	fmt.Println("请输入成绩:")
	fmt.Scanln(&score)

	//多分支判断
	if score == 100 {
		fmt.Println("奖励一辆BMW")
	} else if score > 80 && score <= 99 {
		fmt.Println("奖励一台iphone7plus")
	} else if score >= 60 && score <= 80 {
		fmt.Println("奖励一个 iPad")
	} else {
		fmt.Println("什么都不奖励")
	}

	//使用陷阱.....只会输出ok1...

	var n int = 10
	if n > 9 {
		fmt.Println("ok1") //输出 ok1
	} else if  n > 6 {
		fmt.Println("ok2")
	} else if n > 3 {
		fmt.Println("ok3")
	} else {
		fmt.Println("ok4")
	} */

	// var b bool = true
	// if b == false { 	//如果写成 b = false; 能编译通过吗？如果能，结果是？
	// 	fmt.Println("a")
	// } else if b {
	// 	fmt.Println("b") // b
	// } else if !b { 
	// 	fmt.Println("c")//c
	// } else {
	// 	fmt.Println("d")
	// }
	

	//求ax2+bx+c=0方程的根。a,b,c分别为函数的参数，如果：b2-4ac>0，则有两个解；
	// b2-4ac=0，则有一个解；b2-4ac<0，则无解； 
	// 提示1：x1=(-b+sqrt(b2-4ac))/2a                            
	//        X2=(-b-sqrt(b2-4ac))/2a
	// 提示2：math.Sqrt(num); 可以求平方根 需要引入 math包

	//分析思路
	//1. a,b,c 是三个float64
	//2. 使用到给出的数学公式 
	//3. 使用到多分支
	//4. 使用math.Squr方法 =》手册

	//走代码
	// var a float64 = 2.0
	// var b float64 = 4.0
	// var c float64 = 2.0

	// m := b * b - 4 * a * c
	// //多分支判断
	// if m > 0 {
	// 	x1 := (-b + math.Sqrt(m)) / 2 * a
	// 	x2 := (-b - math.Sqrt(m)) / 2 * a
	// 	fmt.Printf("x1=%v x2=%v", x1, x2)
	// } else if m == 0 {
	// 	x1 := (-b + math.Sqrt(m)) / 2 * a
	// 	fmt.Printf("x1=%v", x1)
	// } else {
	// 	fmt.Println("无解...")
	// }


	// 大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定的条件：
	//高：180cm以上；富：财富1千万以上；帅：是。条件从控制台输入。
	// 如果这三个条件同时满足，则：“我一定要嫁给他!!!”
	// 如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。”
	// 如果三个条件都不满足，则：“不嫁！”

	// var height int32  | var money float32 | var handsome bool

	//分析思路
	//1. 应该设计三个变量 var height int32  | var money float32 | var handsome bool
	//2. 而且需要从终端输入 fmt.Scanln
	//3. 使用多分支if--else if -- else
	var height int32
	var money float32
	var handsome bool

	fmt.Println("请输入身高(厘米)")
	fmt.Scanln(&height)
	fmt.Println("请输入财富(千万)")
	fmt.Scanln(&money)
	fmt.Println("请输入是否帅(true/false)")
	fmt.Scanln(&handsome)

	if height > 180 && money > 1.0 && handsome {
		fmt.Println("我一定要嫁给他!!!")
	} else if height > 180 || money > 1.0 || handsome {
		fmt.Println("嫁吧，比上不足，比下有余")
	} else {
		fmt.Println("不嫁....")
	}



}

2. switch

fallthrough:
switch穿透，会继续下一个switch

package main
import (
	"fmt" 
)


//写一个非常简单的函数
func test(char byte) byte {
	return char + 1
}

func main() {

	// 	案例：
	// 请编写一个程序，该程序可以接收一个字符，比如: a,b,c,d,e,f,g  
	// a表示星期一，b表示星期二 …  根据用户的输入显示相依的信息.

	// 要求使用 switch 语句完成

	//分析思路
	//1. 定义一个变量接收字符
	//2. 使用switch完成
	// var key byte 
	// fmt.Println("请输入一个字符 a,b,c,d,e,f,g")
	// fmt.Scanf("%c", &key)

	// switch test(key)+1 { //将语法现象
	// 	case 'a':
	// 		fmt.Println("周一, 猴子穿新衣")
	// 	case 'b':
	// 		fmt.Println("周二，猴子当小二")
	// 	case 'c':
	// 		fmt.Println("周三，猴子爬雪山")
	// 	//...
	// 	default:
	// 		fmt.Println("输入有误...")
	// }


	// var n1 int32 = 51
	// var n2 int32 = 20
	// switch n1 {
	// 	case n2, 10, 5 :  // case 后面可以有多个表达式
	// 		fmt.Println("ok1")
	// 	case 90 : 
	// 		fmt.Println("ok2~")
		
	// }


	//switch 后也可以不带表达式，类似 if --else分支来使用。【案例演示】
	var age int = 10
	
	switch {
		case age == 10 :
			fmt.Println("age == 10")
		case age == 20 :
			fmt.Println("age == 20")
		default :
			fmt.Println("没有匹配到")
	}
	
	//case 中也可以对 范围进行判断
	var score int = 90
	switch {
		case score > 90 :
			fmt.Println("成绩优秀..")
		case score >=70 && score <= 90 :
			fmt.Println("成绩优良...")
		case score >= 60 && score < 70 :
			fmt.Println("成绩及格...")
		default :
			fmt.Println("不及格")
	}


	//switch 后也可以直接声明/定义一个变量，分号结束，不推荐
	
	switch grade := 90; { // 在golang中，可以这样写
		case grade > 90 :
			fmt.Println("成绩优秀~..")
		case grade >=70 && grade <= 90 :
			fmt.Println("成绩优良~...")
		case grade >= 60 && grade < 70 :
			fmt.Println("成绩及格~...")
		default :
			fmt.Println("不及格~")
	}

	//switch 的穿透 fallthrought
	var num int = 10
	switch num {
		case 10:
			fmt.Println("ok1")
			fallthrough //默认只能穿透一层
		case 20:
			fmt.Println("ok2")
			fallthrough
		case 30:
			fmt.Println("ok3")	
		default:
			fmt.Println("没有匹配到..")
	}
}

3. for

package main
import (
	"fmt" 
)

func main() {
	//输出10句 "你好，尚硅谷"

	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")

	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")


	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")
	// fmt.Println("你好，尚硅谷")

	//golang中，有循环控制语句来处理循环的执行某段代码的方法->for循环
	//for循环快速入门
	
	for i := 1; i <= 10; i++ {
		fmt.Println("你好，尚硅谷", i)
	}



	//for循环的第二种写法
	j := 1 //循环变量初始化
	for j <= 10 { //循环条件
		
		fmt.Println("你好，尚硅谷~", j)
		j++ //循环变量迭代
	}

	//for循环的第三种写法, 这种写法通常会配合break使用
	k := 1
	for {  // 这里也等价 for ; ; { 
		if k <= 10 {
			fmt.Println("ok~~", k)
		} else {
			break //break就是跳出这个for循环
		}
		k++
	}


	//字符串遍历方式1-传统方式
	// var str string = "hello,world!北京"
	// for i := 0; i < len(str); i++ {
	// 	fmt.Printf("%c \n", str[i]) //使用到下标...
	// }

	//字符串遍历方式1-传统方式
	var str string = "hello,world!北京"
	str2 := []rune(str) // 就是把 str 转成 []rune
	for i := 0; i < len(str2); i++ {
		fmt.Printf("%c \n", str2[i]) //使用到下标...
	}

	fmt.Println()
	//字符串遍历方式2-for-range
	str = "abc~ok上海"
	for index, val := range str {
		fmt.Printf("index=%d, val=%c \n", index, val)
	}
}

4. break

package main
import (
	"fmt"
	"math/rand"
	"time"
)

func main() {

	//我们为了生成一个随机数，还需要个rand设置一个种子.
	//time.Now().Unix() : 返回一个从1970:01:01 的0时0分0秒到现在的秒数
	//rand.Seed(time.Now().Unix())
	//如何随机的生成1-100整数
	//n := rand.Intn(100) + 1 // [0 100)
	//fmt.Println(n)

	//随机生成1-100的一个数，直到生成了99这个数，看看你一共用了几次
	//分析思路：
	//编写一个无限循环的控制，然后不停的随机生成数，当生成了99时，就退出这个无限循环==》break
	var count int = 0
	for {
		rand.Seed(time.Now().UnixNano())
		n := rand.Intn(100) + 1
		fmt.Println("n=", n)
		count++
		if (n == 99) {
			break //表示跳出for循环
		}
	}

	fmt.Println("生成 99 一共使用了 ", count)


	//这里演示一下指定标签的形式来使用 break
	lable2: 
	for i := 0; i < 4; i++ {
		//lable1: // 设置一个标签
		for j := 0; j < 10; j++ {
			if j == 2 {
				//break // break 默认会跳出最近的for循环
				//break lable1 
				break lable2 // j=0 j=1
			}
			fmt.Println("j=", j) 
		}
	}

	
}

5. continue

package main
import "fmt"
func main() {

	//continue案例
	//这里演示一下指定标签的形式来使用 
	//lable2: 
	// for i := 0; i < 4; i++ {
	// 	//lable1: // 设置一个标签
	// 	for j := 0; j < 10; j++ {
	// 		if j == 2 {
	// 			continue 
	// 		}
	// 		fmt.Println("j=", j) 
	// 	}
	// }

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

6. goto

package main
import (
	"fmt"
)

func main() {

	// var n int = 30
	// 演示goto的使用
	// fmt.Println("ok1")
	// if n > 20 {
	// 	goto label1
	// }
	// fmt.Println("ok2")
	// fmt.Println("ok3")
	// fmt.Println("ok4")
	// label1:
	// fmt.Println("ok5")
	// fmt.Println("ok6")
	// fmt.Println("ok7")



	var n int = 30
	//演示return的使用
	fmt.Println("ok1")
	if n > 20 {
		return
	}
	fmt.Println("ok2")
	fmt.Println("ok3")
	fmt.Println("ok4")
	fmt.Println("ok5")
	fmt.Println("ok6")
	fmt.Println("ok7")
}