写在前面

本文主要介绍Go的基本控制语句，包括条件语句、循环语句、选择语句、跳转语句，掌握并灵活运用这几种语句基本上就能玩转各种程序的逻辑啦

条件语句

条件语句，即if-else结构语句，用于根据某个条件是否成立来执行相应的语句

• if 结构

var a = 10
if a > 1 {
	fmt.Println(a)
}

• if-else结构

var a = 10
if a > 1 {
	fmt.Println("a>1")
} else{
	fmt.Println("a<1")
}

• if-else if结构 （可以嵌套多个else if结构）

var a = 10
if a > 0 {
	fmt.Println("a>0")
} else if a == 0 {
	fmt.Println("a==0")
} else {
	fmt.Println("a<0")
}

• 支持初始化表达式，即可以在if 后面初始化一个变量，类似于我们在其它编程语言中使用for语句那样先定义一个变量。

if a := 1; a > 0 {
	fmt.Println(a)
}
if a,b := 1,2; a < b{
	fmt.Println("a<b")
}

    需要注意的是，初始化语句中的变量是一个局部变量，只在该条件语句内有效。如果外部有同名变量，在该语句内将被隐藏
    在使用条件语句时，需要注意以下几点格式：

• 条件表达式没有括号
• 左大括号{必须要和if或else (if)在同一行
• 代码块中间的右大括号}必须位于else (if)在同一行
• 大括号不能省略，即使括号里只有一条语句
• 支持单行模式（全部写在一行），不推荐

循环语句

循环语句用于重复执行程序中某些语句，在Go中循环语句只有个for结构一种，没有while，但是Go中的for语句比其它编程语言中的for要灵活得多，足以应多各种循环操作

• 经典计数结构

for i := 0; i < 3; i++ {
	fmt.Println(i)
}

    这个结构应该不用多作解释了，不过有几点需要注意下：

1. for后面的语句不需要用括号括起来，用分号相隔即可
2. 左大括号{必须和for语句在同一行
3. 条件判断语句每次循环都会执行，因此不建议在条件判断语句中使用函数，尽量提前计算好
4. 计数变量可以使用多个，如下所示

for i, j := 1, 10; i < j; i, j = i+1, j-1 {
		fmt.Println(i, j)
}

• 条件判断结构

i := 5
for i >= 0 {
	fmt.Println(i)
	i--
}

    这种结构就是省略掉了计数器的定义以及修改，只保留中间的条件判断语句。实现了while(条件){...}的功能

• 无限循环结构

i := 1
for{
	i++
	if i > 3 {
		break
	}
	fmt.Println(i)
}

    这种结构省略了for后面的循环控制语句，直接for{}的形式，其实这是一个无限循环体。当然，它可以在循环体内搭配条件语句和break语句来跳出循环体，像上面的代码所示，实际上实现了do{...}while(条件)的功能

• for-range结构

array := [5]int{1, 2, 3, 4, 5}
for i, v := range array {
	fmt.Println(i, v)
}

    for-range是go特有的一种循环结构，可以用来迭代数组、切片、map等集合，如上面代码所示是遍历一个数组array，其中返回的变量i，v分别是数组的索引和对应的值。需要注意的是：返回的值仅仅是集合中对应索引的值的拷贝，因此对它作任何修改是不会影响原来集合中的值的。比如在上面的代码中，如果在循环体内对v进行修改或者赋值，并不会影响原来的数组array中的值。
    如果只需要返回索引或者值中的一个，可以用_来替代抛弃值：

array := [5]int{1, 2, 3, 4, 5}
for _, v := range array {
	fmt.Println(v)
}

选择语句

选择语句switch用于多分支选择的情况，与其它编程语言相比，go的switch语句更加灵活。

• 基本结构

switch val {
	case val1:
		...
	case val2:
		...
	default:
		...
}

• val可以是任何类型，val1、val2则可以同类型的任何值。类型不局限于基本类型，还可以是表达式，但必须是相同的类型
• 左大括号{必须和switch在同一行
• 一旦匹配到某个分支，在执行完相应的代码后会退出整个switch代码块，不需要使用break来显示退出
• 如果执行完某个分支后，还希望继续执行后续代码，可以使用fallthrough关键字来执行

i := 0
switch i {
	case 0 : 
		fmt.Println("0")    //进入该分支执行完后即退出switch
	case 1:  
		fmt.Println("1")    //不会进入这个分支
}

switch i {
	case 0 : 
		fmt.Println("0")     //首先进入这个分支执行
		fallthrough
	case 1:  
		fmt.Println("1")    //由于上面有fallthrough，所以会进入本分支执行
}

• case后面还可跟多个值，同时测试多个可能符合条件的值，只要有一个符合即进入分支

i := 3
switch i {
	case 0, 1:
		fmt.Println("0 or 1")
	case 2, 3:
		fmt.Println("2 or 3")         //进入该分支
	default:
		fmt.Println("none")
}

• 直接判断条件分支结构

a := 1
b := 2
switch {
	case a < b:
		fmt.Println("a<b")
	case a == b:
		fmt.Println("a==b")
	case a > b:
		fmt.Println("a>b")
}

    这种结构中，switch不提供任何被判断的值，直接在每个case分支中测试条件是否成立，条件成立则执行分支。可以用来替代if-else语句。

• 包含初始化语句结构

switch a,b:=1,2; {
	case a < b :
		fmt.Println("a<b")
	case a == b:
		fmt.Println("a==b")
	case a > b:
		fmt.Println("a>b") 
}

    这种结构中，switch后面可以初始化一些变量值

跳转语句

go中跳转语句包括了break、continue、goto三种，它们都可以配合标签使用

• break语句

for i := 0; i < 10; i++ {
	for j := 0; j < 5; j++ {
		if j > 3 {
			break
		}
	}
}
//运行结果
0 0
0 1
1 0
1 1
2 0
2 1

    默认用法下，执行break会跳出（结束）该语句所在的那层循环。但如果搭配标签使用，break则可以跳出和标签同层的循环

LABEL:
for {
 	for i := 0; i < 10; i++ {
 		if i > 2 {
 			break LABEL
 		} else {
 			fmt.Println(i)
 		}
 	}
 }
 fmt.Println("OK")
//运行结果
0
1
2
OK

• continue语句

for i := 0; i < 5; i++ {
	if i == 3 {
		continue
	}
	fmt.Println(i)
}
 //运行的结果是
0 0
1 0
1 2
2 0
2 2
3 0
3 2
4 0
4 2

    默认用法下，continue是结束本次循环，进入下一次循环，它的作用范围也是continue所在的同一层循环。同样的，continue也可以搭配标签使用，这样就可以作用与标签所在同一层的循环体。

Label:
for i := 0; i < 5; i++ {
	for j := 0; j < 3; j++ {
		if j == 1 {
			continue Label
		}
		fmt.Println(i, j)
	}
}
//运行的结果是
0 0
1 0
2 0
3 0
4 0

• goto语句
      goto语句是用于调整程序执行的位置，goto语句需要配合标签使用，直接将程序指向标签所在的位置往下执行。需要注意的是，goto的标签一般要放在循环之后。

for i:=1 {
	i++
	if i > 3 {
		goto LABEL
	}
	fmt.Println(i)
}
LABEL:
fmt.Println("goto label")
//运行结果
1
2
3
goto label

    此外，如果定义了标签名却没有使用，将引起编译错误