Go (一) 基础部分2 -- if条件判断,for循环语句

一、if 条件语句

1.1、if 条件判断，Go语言中if条件判断的格式如下：

if 表达式1 {
    执行代码1
} else if 表达式2 {
    执行代码2
} else {
    执行代码3
}

func main() {
	// 例子1：
	szq := 100
	if szq >= 90 {
		fmt.Println("A")
	} else if szq > 75 {
		fmt.Println("B")
	} else {
		fmt.Println("C")
	}

    // 例子2：
	// if条件判断特殊写法，可以在 if 表达式之前添加一个执行语句"score := 65;"，再根据变量值进行判断：
	if score := 65; score >= 90 {
		fmt.Println("A")
	} else if score > 75 {
		fmt.Println("B")
	} else {
		fmt.Println("C")
	}
    // 例子2的完整写法是这样(这么理解)
    score := 65
	if score >= 90 {
		fmt.Println("A")
	} else if score > 75 {
		fmt.Println("B")
	} else {
		fmt.Println("C")
	}

    // 例子3：&& 与 || (and 与 or)
	var x int = 5
	var y int = 4
	if x > 3 && y > 3 {
		fmt.Println(x+y)
	}
	if x > 10 || y > 3 {
		fmt.Println(x+y)
	}

    // 例子4：!  (not)
	var a bool = false
	if a == false {
		fmt.Println("a")  //返回值：a
	}

	var b bool = false
	if ! b {
		fmt.Println("b")  //返回值：b
	}
}

二、for 循环语句

2.1、for 循环，(Go 语言中的所有循环类型均可以使用for关键字来完成 ，只有for循环，无其他循环)，for循环可以通过break、goto、return、panic语句强制退出循环。

for 初始语句;条件表达式;结束语句{
    循环体语句
}

func main() {
	// 常用：条件表达式返回true时循环体不停地进行循环，直到条件表达式返回false时自动退出循环。
	for i := 0; i <= 10; i += 1 {
		fmt.Println(i)
	}

	// 不常用：for循环的初始语句可以被忽略，但是初始语句后的分号必须要写，例如：
	b := 0
	for ; b < 10; b += 1 {
		fmt.Println(b)
	}

	// 不常用：for循环的初始语句和结束语句都可以省略，例如：
	c := 0
	for c < 10 {
		fmt.Println(c)
		c += 1
	}
}

2.2、循环控制语句  break  continue

1.不使用标记，break 结束本层循环

func main() {
	// 不使用标记，break只结束本层的循环
	fmt.Println("---- break ----")
	for i := 1; i <= 3; i++ {
		fmt.Printf("i: %d\n", i)
		for i2 := 11; i2 <= 13; i2++ {
			fmt.Printf("i2: %d\n", i2)
			break
		}
	}
}
//---- break ----
//i: 1
//i2: 11
//i: 2
//i2: 11
//i: 3
//i2: 11

2.使用标记，break 结束标记内的所有循环

func main() {
	// 使用标记，break掉标记内的所有循环
	fmt.Println("---- break label ----")
re:
	for i := 1; i <= 3; i++ {
		fmt.Printf("i: %d\n", i)
		for i2 := 11; i2 <= 13; i2++ {
			fmt.Printf("i2: %d\n", i2)
			break re
		}
	}
}
//---- break label ----
//i: 1
//i2: 11

3.不使用标记，continue 跳过此次循环，进入下一次循环

// 例子1：
func main() {
	for a := 10; a < 20; a += 1 {
		if a == 15 {
			/* 当a=15时，跳过此次循环，进入下一次循环 */
			continue
		}
		fmt.Printf("a 的值为 : %d\n", a)
	}
}

// 例子2：
func main() {
	fmt.Println("---- continue ---- ")
	for i := 1; i <= 3; i++ {
		fmt.Printf("i: %d\n", i)
		for i2 := 11; i2 <= 13; i2++ {
			fmt.Printf("i2: %d\n", i2)
			continue
		}
	}
}
//---- continue ----
//i: 1
//i2: 11
//i2: 12
//i2: 13
//i: 2
//i2: 11
//i2: 12
//i2: 13
//i: 3
//i2: 11
//i2: 12
//i2: 13

4.使用标记，continue 跳出当前循环，从标记处开始下一次循环

	// 使用标记，跳出当前循环，从标记处开始下一次循环
	fmt.Println("---- continue label ----")
re:
	for i := 1; i <= 3; i++ {
		fmt.Printf("i: %d\n", i)
		for i2 := 11; i2 <= 13; i2++ {
			fmt.Printf("i2: %d\n", i2)
			continue re
		}
	}
	//i: 1
	//i2: 11
	//i: 2
	//i2: 11
	//i: 3
	//i2: 11

2.3.1、嵌套循环  9*9乘法表

func main() {
	for i:=1;i<=9;i++{
		for j:=1;j<=i;j++{
			fmt.Printf("%v * %v = %v \t",i,j,i*j)
		}
		fmt.Println()
	}
}

// 标准版:
func main() {
	println("切片解决九九乘法表")
	var num = []int{1, 2, 3, 4, 5, 6, 7, 8, 9} //定义切片
	for i := 1; i < 10; i++ {
		for j := 1; j < i+1; j++ {
			value := num[j-1] * i //计算
			fmt.Printf("%d*%d=%d\t", j, i, value)
		}
		fmt.Println()
	}
}

2.3.2、嵌套循环  金字塔

// 普通金字塔
func main() {
	num:=5
	for i:=1;i<=num;i++ {
		// 打印空格
		for k:=1;k<=num-i;k++ {
			fmt.Print(" ")
		}
		// 打印"*"
		for j:=1;j<=2*i-1;j++{
			fmt.Print("*")
		}
		// 换行
		fmt.Println()
	}
}

// 空心金字塔
func main() {
	num:=5
	for i:=1;i<=num;i++ {
		// 打印空格
		for k:=1;k<=num-i;k++ {
			fmt.Print(" ")
		}
		// 打印"*"
		for j:=1;j<=2*i-1;j++{
			// 这里判断是打印"*"还是"空格"
			if j == 1 || j == 2*i-1 || i == num {
				fmt.Print("*")
			} else {
				fmt.Print(" ")
			}
		}
		// 换行
		fmt.Println()
	}
}

2.4、for range (键,值 循环)
Go语言中可以使用for range遍历数组、切片、字符串、map 及通道（channel）。 通过for range遍历的返回值有以下规律：
1、数组、切片、字符串返回索引和值。
2、map返回键和值。
3、通道（channel）只返回通道内的值。

for range例子1：循环字符

func main() {
	// i 表示索引
	// v 表示对应的值(英文字符占1位，中文字符占3位)
	szq := "he沙河su"
	for i, v := range szq {
		fmt.Printf("%v %c\n", i, v)
	}
}
//0 h
//1 e
//2 沙
//5 河
//8 s
//9 u

for range例子2：循环数组

func main() {
	nums := []int{1, 2, 3, 4}
	length := 0
	for _, num := range nums {
		length += num
		println(num)
	}
	fmt.Println(length) // 10
}

for range 特殊例子：for range 数组时，如果未写参数的话，循环的次数为 len(nums)

func main() {
	nums := []int{1, 2, 3, 4}
	length := 0
	// for range 数组时，如果未写参数的话，循环的次数为 len(nums)
	for range nums {
		length += 1
	}
	fmt.Println(length) // 4
}

for range 特殊例子：for range 数组时，只写一个参数时，n的值默认为索引

func main() {
	nums := []int{1, 2, 3, 4}
	length := 0
	// for range 数组时，只写一个参数时，n的值默认为索引
	for n := range nums {
		length += n
	}
	fmt.Println(length) // 6
}

2.5、switch case

变量名
switch 变量名 {
case 条件:
表达式
default:
表达式
}

使用switch语句可方便地对大量的值进行条件判断。

每个switch只能有一个default分支
一个分支可以有单个或多个值，多个case值中间使用英文逗号分隔。

func main() {
	finger := 8
	// switch case
	// switch 简化大量的判断（一个变量和具体的值做比较）
	switch finger {
	case 1:
		fmt.Println("大拇指")
	case 2:
		fmt.Println("食指")
	case 3:
		fmt.Println("中指")
	case 4:
		fmt.Println("无名指")
	case 5:
		fmt.Println("小拇指")
	default:
		fmt.Println("无效的输入！")
	}

	//Go语言规定每个switch只能有一个default分支。
	//一个分支可以有多个值，多个case值中间使用英文逗号分隔。
	num := 7
	switch num {
	case 1, 3, 5, 7, 9:
		fmt.Println("奇数")
	case 2, 4, 6, 8:
		fmt.Println("偶数")
	default:
		fmt.Println(num)
	}
	// 输出结果：奇数

	//分支还可以使用表达式，这时候switch语句后面不需要再跟判断变量。例如：switch age {} 就写为 switch {}
	age := 30
	switch {
	case age < 25:
		fmt.Println("好好学习吧")
	case age > 25 && age < 35:
		fmt.Println("好好工作吧")
	case age > 60:
		fmt.Println("好好享受吧")
	default:
		fmt.Println("活着真好")
	}
	// 输出结果：好好工作吧
}