GO语言学习笔记7:程序流程控制，IF、ELSE、FOR等

在程序中，运行的流程控制决定了程序如何执行，主要分为三大流程，基本每个高级编程语言都有几乎一样的流程控制语句。GO语言做为一个创新语言，在流程控制上和其它语言是有一点区别的。

一、顺序控制

程序正常情况下会从上到下执行，中间没有任何判断和跳转。GO语言可以通过goto语言对程序执行顺序进行跳转控制。goto在汇编语言里使用得比较多，可以无条件地转移到程序指定的行，在高级语言中容易让程序产生混乱在实际开发中不建议使用。GOTO语言通常与条件语句配合使用，可以用来实现条件转移，跳出循环体等功能。

基本语法：goto lable ... lable:statement

i := 0
goto myLabel //跳到myLabel位置去执行
myLabel2:
fmt.Println("我在前面的，居然比下面代码晚执行~")
i++
myLabel:
if i < 1 {
	fmt.Println("myLabel虽然在后面，但我有goto加持~")
	goto myLabel2//跳到myLabel2位置去执行
}

二、分支控制if..else、switch...case

GO语言里分支控制有2种方式，if..else类和switch...case，用法和其它程序一样，GO语言不需要写小括号但必须有大括号，所以if语言最少要3行代码。

if 条件语句{
    执行操作
}

//基本条件语句
i := 1 //定义变量1
if i == 1 {
	fmt.Println("i=", i)//如果条件满足就打印结果~
}

//GOlang支持在IF中直接定义一个变量，i仅在if...else的{}代码块范围内有效
if i := 0; i > 1{
	fmt.Println("i=", i)
} else {
	fmt.Println("i<1,值为", i)
}

//GOlang会先运算再判断
i := 4
if i+2 == 6 {
	fmt.Println("这个条件是满足的哦~", i)
} else {
	fmt.Println("这个条件不满足~", i)
}


//条件不满足语句
i = 2
if i == 1 {
	fmt.Println("i=", i)
} else {
	fmt.Println("i不等1，真实的值：", i)
}

//多条件语句
i = 3
if i == 1 {
	fmt.Println("i=", i)
} else if i > 1 {
	fmt.Println("i大于1，值为：", i)
}else {
	fmt.Println("以上条件都不是，真实的值：", i)
}

//同时判断多个条件
i = 0
if i >= 1 {
	fmt.Println("i=", i)
} else {
	fmt.Println("i<1,值为", i)
}
//将上面语句拆分成2个判断
i := 0
if i == 0 || i < 1 {
	fmt.Println("i=", i)
} else {
	fmt.Println("i<1,值为", i)
}

//继续拆分成嵌套
i := 4
if i < 6 {
	if i == 5 {
		fmt.Println("i=", i)
	}else{
		fmt.Println("i比5大，值为：", i)
	}
} else {
	fmt.Println("i<1,值为", i)
}

//同时满足多个条件
i := 4
if i > 3 && i < 6 {
	fmt.Println("要求i同时要大于3并小于6~", i)
} else {
	fmt.Println("取值不在4和5之间~", i)
}

下面来1个在开发中会用到的实际判断闰年：

分析：算闰年的方法是用年份除以4，得出的是整数即该年是闰年，但以00结尾的年分就要除以400，相同的出的是证书才是闰年。

year := 2100
if (year%4 == 0 && year%100 != 0) || year%400 == 0 {
	fmt.Println(year, "是一个闰年~")
} else {
	fmt.Println(year, "不是闰年哦~")//2100 不是闰年哦~
}

使用switch...case可以替换多个if..else if...else，让代码清晰更易读。

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

func main() {
	rand.Seed(time.Now().Unix()) //使用Unix时间戳做为随机因子
	pai := rand.Intn(10)         //生成1个10以内的随机数
	switch pai {
	case 1:
		fmt.Println("你拍一，我拍一，小猴子穿新衣~")
	case 2:
		fmt.Println("拍二，我拍二，两个小孩梳小辫~")
	case 3:
		fmt.Println("你拍三，我拍三，三个小孩吃饼干~")
	case 4:
		fmt.Println("你拍四，我拍四，四个小孩写大字~")
	case 5:
		fmt.Println("你拍五，我拍五，五个小孩来跳舞~")
	case 6:
		fmt.Println("你拍六，我拍六，六个小孩吃石榴~")
	case 7:
		fmt.Println("你拍七，我拍七，七个小孩做游戏~")
	case 8:
		fmt.Println("你拍八，我拍八，八个小孩吹喇叭~")
	case 9:
		fmt.Println("你拍九，我拍九，九个小孩找皮球~")
	case 10:
		fmt.Println("你拍十，我拍十，十个小孩来剪纸~")
	default:
		fmt.Println("啊~哦~你拍到马屁股上了~")
	}
}

case后是一个表达式（常量、变量、有返回值的函数、运行结果等）和IF的条件语句一样，case后面条件表达式的数据类型要与switch一样，如果case后面有多个表达式，使用英文的逗号隔开，如果case后面值是常量，要求不能重复。

由于GO语言支持case多个条件表达式，所以case后面不需要带break,程序匹配下一个case就会执行对应的代码块，然后退出switch，如果一个都不能匹配则执行default，default不是必须语句！

age := 5
switch age {
case 0, 1, 2, 3, 4, 5: //可以使用多个表达式
	fmt.Println("你还是一个小baby，可以放心的玩耍~")
case 6,7,8,9,10,11:
	fmt.Println("该上小学呢~")
case 12,13,14:
	fmt.Println("上初中呢~")
case 15,16,17:
	fmt.Println("上高中呢~")
case 18,19,20,21:
	fmt.Println("上大学呢~")
case 22,23,24,25,26:
	fmt.Println("快去找工作吧~")
default:
	fmt.Println("老大爷、老阿姨你好，再见~")
}

switch后可以不带表示式，这样就可以当做if...then...else分支来使用：

age := 15
switch {
case age <= 5: //条件bool表达式
	fmt.Println("你还是一个小baby，可以放心的玩耍~")
case age >= 5 && age < 12:
	fmt.Println("该上小学呢~")
case age >= 12 && age < 15:
	fmt.Println("上初中呢~")
case age >= 15 && age < 18:
	fmt.Println("上高中呢~")
case age >= 18 && age < 22:
	fmt.Println("上大学呢~")
case age >= 22 && age < 25:
	fmt.Println("快去找工作吧~")
default:
	fmt.Println("老大爷、老阿姨你好，再见~")
}

没有条件的 switch 同 switch true 一样。这种形式能将一长串 if-then-else 写得更加清晰。

swith 后面可以声明/定义一个变量，以分号结束，但不推荐，这样写代码不清晰，以后在DEBUG的时候不容易定位错误，下面做个小演示

switch age := 18; { //在switch里直接定义变量
case age < 18:
	fmt.Println("你是个未成年~")
default:
	fmt.Println("可以去网吧呢~")
}

switch穿透--fallthrough,如果在case的代码块里放入fallthrough后会继续执行下一个case,实现switch穿透，做为一个知识点了解，在实际开发上运用比较少~

switch {
case false:
	fmt.Println("第1个条件为假")
	fallthrough //由于条件为假，这个代码块不会执行
case true:
	fmt.Println("第2个条件为真")
	fallthrough//当前是switch 第1个真的条件，会执行，fallthrough会穿透到下面条件为假的代码。
case false:
	fmt.Println("第3个条件为假")
	fallthrough//虽然当前条件为假，由于上层穿透，所以这里的代码也会执行并继续穿透到下层
case false:
	fmt.Println("第4个条件为真")//这里也为假，能执行到是因为上层穿透
case true:
	fmt.Println("第5个条件为收")
	fallthrough//这里的代码虽然为真，由于上层提前满足了条件，也没有穿透代码，所以并不会执行
default:
	fmt.Println("这里是default case")
}
/*
第2个条件为真
第3个条件为假
第4个条件为真
*/

之所以GO语言中有一个fallthrough，是因为GO的编译器会自动给写个case代码结束的时候加上break语句，写上了fallthrough就类型于其它编程语言中不写break的情况。

 

Type Switch:switch语句还可以被用于type-switch来判断某个interface变量中实际指向的变量类型：

ar x interface{}
var y = 10.0
x = y
switch i := x.(type) {
case nil:
	fmt.Printf("x类型：%T", i)
case int:
	fmt.Println("X是int类型")
case float32, float64:
	fmt.Println("X是float类型")
default:
	fmt.Println("未知类型")
}

 三、循环控制for

GO语言里循环控制有实际有2个方式实现，第1个递归函数、第2个就是for循环了，不像其它语言有while、do...while,在GO语言里就只使用FOR来完成。

for i:=0;i<10;i++{
	fmt.Println("我是第",i,"次循环")//将打印0~9共10次循环
}

语法：for 循环变量初始化;循环条件;变量迭代{执行循环的代码块}，这里的i属于for的内部变量，只能在for的代码块里访问，结果循环后，i的值将在内存中彻底被销毁，如果我们要访问在i，就需要在外部先定义i再放入for循环里。

i := 0
for ; i < 10; i++ {
	fmt.Println("我是第", i, "次循环")
}
fmt.Println("当前i的值为：", i) //当前i的值为： 10

GO语言的循环可以直接写条件，实现其它语言的while：

i := 0
for i < 10 {
	fmt.Println("我是第", i, "次循环")
	i++
}

如果要无限循环（死循环），我们可以简写所有条件表达式，直接只写for即可，要退出死循环需要配合break语句退出循环。

i := 0
for {
	fmt.Println("我是第", i, "次循环")
	i++
	if i > 10 {
		break
	}
}

上面介绍了break是退出循环，下面介绍一下跳过当前循环，继续执行下一个循环的语句：continue

for i := 1; i <= 9; i++ {
	if i == 4 {
		continue//当i等4的时候，不会输入：“当前是第 4 次循环”
	}
	fmt.Println("当前是第", i, "次循环") //换行
}

使用无限循环代替其它语言的while效果：

//除了上面的while循环的模拟我们也可以使用下面这样的
for{
	if 条件{
		break
	}
	循环操作语句
	循环变量迭代
}
//do...while循环模拟
for{
	循环操作语句
	循环变量迭代
	if 条件{
		break
	}
}
//只需要把循环操作语句放前面就实现了do...while

下面使用for的嵌套来1个经典案例，打印九九乘法表：

for i := 1; i <= 9; i++ {
	for j := 1; j <= i; j++ {
		fmt.Print(j, "*", i, "=", i*j, " ")
	}
	fmt.Println() //换行
}

 

除非注明，网络人的文章均为原创，转载请以链接形式标明本文地址：https://www.55mx.com/post/76