Go 语言流程控制

对比其它语言的不同之处：

1. 选择语句（If 和 Switch）判断之前可以初始化变量
2. Switch 选择结构中不需要 break 来结束 case 语句
3. 选择语句和循环语句的判断条件都不需要用括号括起来
4. Go 语言如何用 range 函数取字符串中的键和值

选择结构

If 语句

语法：if 条件 { 代码块 }

package main

import (
	"fmt"
)

func main() {

	// 变量初始化
	num := 90

	// 进入条件判断
	if num > 80 {
		fmt.Println("评价：优秀！") // 评价：优秀！
	}
}

If - else 语句

语法：if 条件 { 代码块 } else { 代码块 }

package main

import (
	"fmt"
)

func main() {

	// 变量初始化
	num := 50

	// 进入条件判断
	if num > 60 {
		fmt.Println("评价：合格！") 
	} else {
		fmt.Println("评价：继续努力！") // 评价：继续努力！
	}
}

If - else if - else 语句

语法：if 条件 { 代码块 } else if { 代码块 } else { 代码块 }

package main

import (
	"fmt"
)

func main() {

	// 变量初始化
	num := 50

	// 进入条件判断
	if num > 80 {
		fmt.Println("评价：优秀！")
	} else if num > 60 {
		fmt.Println("评价：及格！")
	} else {
		fmt.Println("评价：加油！") // 评价：加油！
	}
}

Go 语言允许进行条件判断之前进行变量的初始化过程

package main

import (
	"fmt"
)

func main() {

	// 变量初始化及条件判断
	if num := 90; num > 80 {
		fmt.Println("评价：优秀！") // 评价：优秀！
	} else if num > 60 {
		fmt.Println("评价：及格！")
	} else {
		fmt.Println("评价：加油！")
	}
}

If 嵌套

package main

import (
	"fmt"
)

func main() {

	// if 嵌套
	if num := 100; num > 60 {
		fmt.Println("你可以拿到一支铅笔！")

		if num > 80 {
			fmt.Println("你还可以拿到一支圆珠笔！")

			if num > 90 {
				fmt.Println("你还还可以拿到一个笔记本！")
			}
		}
	}

	// outputs：你可以拿到一支铅笔！
	// 			你还可以拿到一支圆珠笔！
	// 			你还还可以拿到一个笔记本！
}

Switch 语句

package main

import (
	"fmt"
)

func main() {

	// 在 switch 语句之前初始化变量
	// num1 := 9

	// 在 switch 语句中初始化变量
	switch num1 := 9; num1 {
	case 10:
		fmt.Println("10 分！")
	case 9:
		fmt.Println("9 分！")
	case 8:
		fmt.Println("8 分！")
	default:
		fmt.Println("低于 8 分！")
	}

	// output：9 分！
}

常用的 Switch 语句形式 – 多条件判断

package main

import (
	"fmt"
)

func main() {

	// 在 switch 语句中初始化变量
	switch num1 := 9; num1 {
	// 将多个判断条件放在一个 case 语句中 -- 用逗号隔开
	case 10, 9, 8:
		fmt.Println("优秀！")
	case 7, 6:
		fmt.Println("良好！")
	case 5, 4, 3, 2, 1, 0:
		fmt.Println("加油！")
	default:
		fmt.Println("乱输是不是！")
	}

	// output：优秀！
}

常用的 Switch 语句形式 – 从下

package main

import (
	"fmt"
)

func main() {

	// fallthrough 代表 case 中语句和其下语句一致
	switch num1 := 9; num1 {
	case 10:
		fallthrough
	case 9:
		fallthrough
	case 8:
		fmt.Println("优秀！")
	}

	// output：优秀！
}

判断闰年

闰年：能被 400 整除或者能被 4 整除却不能被 100 整除的数

package main

import (
	"fmt"
)

func main() {

	var year, month int
	fmt.Println("请输入当前的年份：")
	fmt.Scan(&year)

	if month > 12 || month < 1 {
		fmt.Println("请输入当前的月份：")
		fmt.Scan(&month)
	}

	switch month {
	case 1, 3, 5, 7, 8, 10, 12:
		fmt.Printf("%d 年 %d 月共 31 天", year, month)
	case 4, 6, 9, 11:
		fmt.Printf("%d 年 %d 月共 30 天", year, month)
	case 2:
		if year%400 == 0 || year%4 == 0 && year%100 != 0 {
			fmt.Printf("%d 年 %d 月共 29 天", year, month)
		} else {
			fmt.Printf("%d 年 %d 月共 28 天", year, month)
		}
	}
}

循环结构

For 循环

语法：for 初始化条件;判断条件;条件变化 { 代码块 }

package main

import "fmt"

func main() {

	// 计算 1~10 的和
	sum := 0
	for i := 1; i < 11; i++ {
		sum += i
	}

	fmt.Println(sum) // 55
}

通过 for 循环格式化打印字符串中的每个字符

package main

import "fmt"

func main() {

	str := "love"

	for i := 0; i < len(str); i++ {
		fmt.Printf("%c\n", str[i])
	}

	// outputs: l
	//			o
	//			v
	//			e
}

重点：ranger 范围打印字符串内的字符

语法：for 索引, 值 := range 字符串 { 代码块 }

package main

import "fmt"

func main() {

	str := "love"

	for index, value := range str {
		fmt.Printf("第 %d 个索引的值为：%c\n", index, value)
	}

	// outputs:第 0 个索引的值为：l
	// 		   第 1 个索引的值为：o
	//         第 2 个索引的值为：v
	//         第 3 个索引的值为：e
}

For 循环嵌套

案例一：打印五行五列的星星

package main

import "fmt"

func main() {

	for i := 0; i < 5; i++ {
		for j := 0; j < 5; j++ {
			fmt.Print("*")
		}

		fmt.Print("\n")
	}

	// outputs:*****
	//		   *****
	//         *****
	//		   *****
	//		   *****
}

案例二：自定义兔子问题

package main

import "fmt"

func main() {

	// 自定义场景 -- 一只大兔子 5 元 -- 中兔子 3 元 -- 小兔子 0.5 元
	// 问：拿 100 元买 100 只兔子有哪几种方案

	// 循环次数
	sum := 0

	for big_Rabbit := 0; big_Rabbit < 20; big_Rabbit++ { // 大兔子的数量
		for middle_Rabbit := 0; middle_Rabbit < 30; middle_Rabbit++ { // 中兔子的数量
			sum += 1
			small_Rabbit := 100 - big_Rabbit - middle_Rabbit // 小兔子的数量
			if float64(small_Rabbit)*0.5+float64(middle_Rabbit)*3+float64(big_Rabbit)*5 == 100 {
				fmt.Printf("大兔子：%d，中兔子：%d，小兔子：%d\n", big_Rabbit, middle_Rabbit, small_Rabbit)
			}
		}
	}

	fmt.Println(sum) // 600

	// outputs:大兔子：0，中兔子：20，小兔子：80
	//		   大兔子：5，中兔子：11，小兔子：84
	//         大兔子：10，中兔子：2，小兔子：88
}

跳转结构

Break 语句

作用：中断当前循环（遵循就近原则）

package main

import "fmt"

func main() {

	for i := 0; ; i++ {
		fmt.Print(i)

		if i == 100 {
			break
		}
	}

	// 结果：打印输出 1~100
}

Continue 语句

作用：跳出当前循环，进入下一次循环（遵循就近原则）

package main

import "fmt"

func main() {

	for i := 0; i < 20; i++ {

		if i == 8 {
			continue
		}

		fmt.Print(i)
	}

	// 结果：打印 1~20 （除了 8）
}

Goto 语句

语法：goto 关键字，End 标签（用户起的名字）

package main

import "fmt"

func main() {

	fmt.Println("1")
	goto END

	fmt.Println("2")
	fmt.Println("3")
	fmt.Println("4")

END:
	fmt.Println("5")

	// 结果：打印输出 1 5
}