Go流程控制

Go流程控制

单分支控制

package main
import(
	"fmt"
)

func main(){

	//方式一
	/*if 条件表达式{
		执行代码块
	}*/
	var age1 int
	fmt.Scanln(&age1)
	if age1 > 18 {
		fmt.Println("年龄大于18岁")
	}

	//golang支持在if中直接定义一个变量
	if age2 := 20;age2 > 18 {
		fmt.Println("年龄大于18岁")
	}
}
//一定要有{}

双分支控制

package main
import(
	"fmt"
)

func main(){

	var age int
	fmt.Scanln(&age)

	if age > 18 {
		fmt.Println("年龄大于18")
	} else {
		fmt.Println("年龄小于18")
	}

	//双分支只会执行其中的一个分支
	//else不可另起一行
}

多分支控制

package main
import(
	"fmt"
)

func main(){

	//else不是必须的
	//多分支只能有一个执行入口
	var score int
	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("P")
	}
}

switch分支控制

package main
import(
	"fmt"
)

func main(){

	//匹配项后不需要加break
	//如果switch的表达式的值没有和任何的case的表达式匹配成功，则执行default语句块。执行后退出switch的控制
	//golang的case后的表达式可以有多个，使用逗号，隔开
	//case后面的表达式如果是常量值（字面值），要求不能重复
	//default不是必须的

	var key byte
	fmt.Println("请输入a~c中的一个字符")
	fmt.Scanln(&key)

	switch key{
		case 'a':
			fmt.Println("周一")	
		case 'b':
			fmt.Println("周二")
		case 'c':
			fmt.Println("周三")
		default:
			fmt.Println("输入有误")
	}

	//case后的各个表达式的值的数据类型必须和switch的表达式数据类型一致
	//var n1 int32 = 20
	//var n2 int64 = 20
	/*switch n1{
		case n2 ://错误，n2与n1的数据类型不同
			fmt.Println("dddd")
	}*/

	//switch后可以不带表达式，类似if-else分支使用
	var age int = 20
	switch  {
		case age == 10: 
			fmt.Println("age=10")
		case age == 20: 
			fmt.Println("age=20")
	}

	//switch后也可以直接声明/定义一个变量，以分号结束
	switch grade := 90; {
	case grade > 90:
		fmt.Println("优秀")
	case grade <= 90:
		fmt.Println("差")
	}

	//switch穿透fallthrough，若在case语句块后增加fallthrough，则会继续执行下一个case，也称为switch穿透
	var num int = 10
	switch num{
	case 10:
		fmt.Println("ok1")
		fallthrough//默认只穿一层
	case 20:
		fmt.Println("ok2")
	}

	//Type Switch语句还可以被用于type-switch来判断某个interface变量中实际执行的变量类型
}

for循环控制

package main
import(
	"fmt"
)

func main(){

	//第一种语法格式
	/*
	for 循环变量初始化;循环条件;循环变量迭代{
		循环操作
	}
	*/

	for i := 0; i < 10; i++ {
		fmt.Println("hello")
	}

	//第二种语法格式
	/*
	for 循环判断条件 {
		循环执行语句
	}
	*/

	j := 1
	for j < 10 {
		fmt.Println("hello")
		j++
	}

	//第三种语法格式
	/*
	for {
		循环执行语句
	}
	*/
	//等价for ;;{}为无限循环，需要配合break语句
	k := 1
	for {
		if k <= 10 {
			fmt.Println("ok")
		} else {
			break
		}
		k++
	}

	//Golang提供for-range方式，可以方便遍历字符串和数组
	//传统方式
	var str string = "hello,world"
	for i := 0; i < len(str); i++ {
		fmt.Printf("%c",str[i])//使用下标
	}
	
	//若字符串含有中文，传统遍历方式会出现乱码
	//因为传统的遍历是按字节遍历，而一个汉字对应3个字节
	//可将str转成切片[]rune
	str = "hello,world!北京"
	str2 := []rune(str)//将str转成[]rune
	for i := 0; i < len(str2); i++ {
		fmt.Printf("%c \n",str2[i])
	}

	//使用for-range方式
	//按字符方式进行遍历，字符串可以含有中文
    //for range创建了每个元素的副本，而不是直接返回每个元素的引用
	str = "abc~ok"
	for index,val := range str {
		fmt.Printf("index=%d,val=%c\n",index,val)
	}
    //index=0,val=a
//index=1,val=b
//index=2,val=c
//index=3,val=~
//index=4,val=o
//index=5,val=k
}

while循环的实现

package main
import(
	"fmt"
)

func main(){

	//Go语言没有while和do-while语法，可以通过for循环实现
	/*
	循环变量初始化
	for {
		if 循环条件表达式 {
			break;//跳出for循环
		}
		循环操作（语句）
		循环变量迭代
	}
	*/

	var i int = 1
	for {
		if i >10 {
			break
		}
		fmt.Println("hello,world")
		i++
	}
}

do-while的实现

package main
import(
	"fmt"
)

func main(){

	//Go语言没有while和do-while语法，可以通过for循环实现
	/*
	循环变量初始化
	for {
		循环操作（语句）
		循环变量迭代
		if 循环条件表达式 {
			break;//跳出for循环
		}
	}
	*/

	var i int = 1
	for {
		fmt.Println("hello.world")
		i++
		if i>10 {
			break
		}
	}
}

生成随机数

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

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

break

package main
import(
	"fmt"
)

func main(){
	//break语句出现在多层嵌套的语句块时，可以通过标签指明要终止哪一层语句块
	for i := 0; i < 4; i++ {
		lable1:
		for j := 0; j < 10; j++ {
			if j == 2 {
				//break//break默认会跳出最近的for循环
				break lable1
			}
			fmt.Println("j=",j)
		}
	}
}

跳转控制语句continue

package main
import(
	"fmt"
)

func main(){
	//continue语句用于结束本次循环。继续执行下一次循环
	//continue语句出现在多层嵌套语句体中，可以通过标签指明要跳过哪一层循环
	for i := 0; i < 4; i++ {
		for j := 0; j < 10; j++ {
			if j ==2 {
				continue
			}
			fmt.Println("j=",j)
		}
	}
}

跳转控制语句goto

package main
import(
	"fmt"
)

func main(){
	//Go语言的goto语句可以无条件地转移到程序中指定的行
	//基本语法
	/*
	goto label
	...
	label: statement
	*/
	var n int = 30
	fmt.Println("ok1")
	if n > 20 {
		goto label1
	}
	fmt.Println("ok2")
	label1:
	fmt.Println("ok3")
}