Golang基础-3

Go语言基础

介绍

基础

• 1. 条件语句

• 2. 选择语句

• 3. 循环语句

• 4. goto关键字

介绍

• 本文介绍Go语言中条件语句、选择语句、循环语句、break、continue、goto关键字等相关知识。

基础

1. 条件语句

• 实现程序逻辑时，需要通过不同的判断条件去执行相应的语句。
• Go语言中的条件语句通过判断条件是否为 true/false 来决定执行相关语句。
• Go语言中条件语句有 if、if else、if else if等

package main

import "fmt"

func main() {
	var a int = 16

	// 单分支，大括号必须存在，Go语言格式严格
	if a == 16 {
		fmt.Println("a == 16")
	}

	// 双分支
	a = 20
	if a != 20 {
		fmt.Println("a != 20")
	} else {
		fmt.Println("a == 20")
	}

	// 多分支，else if 分支任意数量、最后的 else 可选
	a = 40
	if a <= 20 {
		fmt.Println("a <= 20")
	} else if a <= 40 {
		fmt.Println("a <= 40")
	} else if a <= 60 {
		fmt.Println("a <= 60")
	} else {
		fmt.Println("a > 60")
	}

	// 局部变量，仅在条件语句作用域内可访问
	a = 30
	if s := 16; s == a {
		fmt.Println("s == a")
	} else {
		fmt.Println("s != a")
	}

	// 分支嵌套，可任意嵌套，实际开发中不要嵌套太多层，嵌套太多层的代码需要优化设计
	a = 80
	if a > 60 {
		if a > 80 {
			fmt.Println("a > 80")
		} else {
			fmt.Println("a <= 80")
		}
	} else if a > 40 {
		if a > 50 {
			fmt.Println("a > 50")
		} else {
			fmt.Println("a <= 50")
		}
	} else {
		fmt.Println("a <= 40")
	}
}

输出结果
a == 16
a == 20
a <= 40
s != a
a <= 80

2. 选择语句

• 根据输入条件的不同选择不同的语句块进行执行（多分支）
• 基本语法

switch 表达式 {
	case 值1, 值2... :
		语句块1
	case 值3, 值4... :
		语句块2
	...
	default : 
		语句块
}

• switch后边是一个表达式（常量值、变量、具有返回值的函数等）

package main

import "fmt"

func main() {
	var a int = 16
	var str string = "id"
	const c int = 20

	// switch后边是常量值
	switch 20 {
	case 20:
		fmt.Println("20")
	default:
		fmt.Println("***")
	}
	// switch后边是变量
	switch a {
	case 20:
		fmt.Println("20")
	default:
		fmt.Println(a)
	}
	// switch后边是常量
	switch c {
	case 20:
		fmt.Println("20")
	default:
		fmt.Println(c)
	}
	// switch后边是字符串
	switch str {
	case "id":
		fmt.Println("id")
	default:
		fmt.Println(str)
	}
	// switch后边是函数
	switch getValue() {
	case 30:
		fmt.Println("30")
	default:
		fmt.Println("***")
	}
}

func getValue() int {
	return 30
}

输出结果
20
16
20
id
30

• switch后边可不带表达式，当作if使用

package main

import "fmt"

func main() {
	var a int = 20
	// switch后边自定义局部变量
	switch {
	case a == 20:
		fmt.Println("a == 20")
	default:
		fmt.Println(a)
	}
}

输出结果：a == 20

• switch后边可直接声明/定义一个变量，分号结束

package main

import "fmt"

func main() {
	// switch后边自定义局部变量
	switch s := 10; s {
	case 10:
		fmt.Println("10")
	default:
		fmt.Println(s)
	}
}

输出结果：10

• switch语句分支Go语言默认执行完符合条件的case后会自动break（跳出switch语句块)，若要执行完当前分支后继续执后一个分支，需要在分支中添加关键字fallthrough

package main

import "fmt"

func main() {
	var a int = 20
	// case 分支使用 fallthrough 穿透
	switch {
	case a == 20:
		fmt.Println("a == 20")
		fallthrough
	case a != 20:
		fmt.Println("a != 20")
	default:
		fmt.Println(a)
	}
}

输出结果
a == 20
a != 20

• case后值的数据类型必须和switch后表达式的数据类型一致
• case后可跟多个表达式，使用逗号分隔

package main

import "fmt"

func main() {
	var a int = 20
	// case 分支多个值
	switch a {
	case 10, 30:
		fmt.Println("10, 30")
	case 20:
		fmt.Println("20")
	default:
		fmt.Println(a)
	}
	// case 分支多个表达式
	switch {
	case a < 10, a > 30:
		fmt.Println("a < 10, a > 30")
	case a >= 10, a <= 30:
		fmt.Println("a >= 10, a <= 30")
	default:
		fmt.Println(a)
	}
}

输出结果
20
a >= 10, a <= 30

• case后边为值时，各case分支的值不能重复
• default语句是可选的

3. 循环语句

• 实际需要重复执行一段代码时，需要循环结构
• Go语言中使用 for 支持循环结构
• break关键字用于跳出当前循环结构
• continue关键字用于当前循环结构中，表示这一轮循环从当前位置结束，返回去重新开始执行下一轮循环
• for 循环可嵌套，切记注意程序执行效率
• for 循环基本语法格式

for 初始表达式; 布尔表达式; 迭代因子 {
	循环体
}

• for-range 用于遍历可迭代对象中的每个元素，例如字符串，数组，切片，映射，通道等

package main

import "fmt"

func main() {
	// 计算数字 1~100 加法
	var sum int = 0

	// 标准 for 循环
	for i := 1; i <= 100; i++ {
		sum += i
	}
	fmt.Println("1 sum: ", sum)

	// for 省略初始化因子
	sum = 0
	var i int = 1
	for ; i <= 100; i++ {
		sum += i
	}
	fmt.Println("2 sum: ", sum)

	// for 省略初始化因子、迭代因子，类似 while 循环
	sum = 0
	i = 1
	for i <= 100 {
		sum += i
		i++
	}
	fmt.Println("3 sum: ", sum)

	// 无限 for 循环
	sum = 0
	i = 1
	for {
		if i <= 100 {
			sum += i
		} else { // i > 100
			break // 注意此处使用 break 跳出 for 循环
		}
		i++
	}
	fmt.Println("4 sum: ", sum)
}

输出结果
1 sum: 5050
2 sum: 5050
3 sum: 5050
4 sum: 5050

package main

import "fmt"

func main() {
	// for-range
	var str string = "今天是sheme天气"
	for i, v := range str {
		fmt.Printf("index: %d, value: %c\n", i, v)
	}
}

输出结果
index: 0, value: 今
index: 3, value: 天
index: 6, value: 是
index: 9, value: s
index: 10, value: h
index: 11, value: e
index: 12, value: n
index: 13, value: m
index: 14, value: e
index: 15, value: 天
index: 18, value: 气

package main

import "fmt"

func main() {
	// for 循环嵌套
	for i := 1; i < 10; i++ {
		for j := i; j < 10; j++ {
			fmt.Printf("%v * %v = %v\t", i, j, i*j)
		}
		fmt.Printf("\n")
	}
}

输出结果
1 * 1 = 1 1 * 2 = 2 1 * 3 = 3 1 * 4 = 4 1 * 5 = 5 1 * 6 = 6 1 * 7 = 7 1 * 8 = 8 1 * 9 = 9
2 * 2 = 4 2 * 3 = 6 2 * 4 = 8 2 * 5 = 10 2 * 6 = 12 2 * 7 = 14 2 * 8 = 16 2 * 9 = 18
3 * 3 = 9 3 * 4 = 12 3 * 5 = 15 3 * 6 = 18 3 * 7 = 21 3 * 8 = 24 3 * 9 = 27
4 * 4 = 16 4 * 5 = 20 4 * 6 = 24 4 * 7 = 28 4 * 8 = 32 4 * 9 = 36
5 * 5 = 25 5 * 6 = 30 5 * 7 = 35 5 * 8 = 40 5 * 9 = 45
6 * 6 = 36 6 * 7 = 42 6 * 8 = 48 6 * 9 = 54
7 * 7 = 49 7 * 8 = 56 7 * 9 = 63
8 * 8 = 64 8 * 9 = 72
9 * 9 = 81

• break跳出循环体

package main

import "fmt"

func main() {
	for i := 0; i < 4; i++ {
		if i == 2 { // 满足条件时跳出 for 循环
			break
		}
		fmt.Println(i)
	}
}

输出结果
0
1

• continue停止当前循环体，开始下一轮循环体

package main

import "fmt"

func main() {
	for i := 0; i < 4; i++ {
		if i == 2 { // 满足条件时，重新执行下一轮循环
			continue
		}
		fmt.Println(i)
	}
}

输出结果
0
1
3

4. goto关键字

• 尽量少使用 goto 关键字
• 通过 goto 语句可以任意跳转到当前函数指定的 label 位置

package main

import "fmt"

func main() {
	fmt.Println("-----1-----")
	fmt.Println("-----2-----")
	fmt.Println("-----3-----")
	goto END
	fmt.Println("-----4-----")
	fmt.Println("-----5-----")
END:
	fmt.Println("-----6-----")
}

输出结果
-----1-----
-----2-----
-----3-----
-----6-----

• break 和 continue 后也可以指定 label 用于指定跳出或跳过指定 label 同层级的循环

package main

import "fmt"

func main() {
END1:
	for i := 0; i < 4; i++ {
		if i == 2 { // 满足条件时，执行跳转
			continue END1
		}
		fmt.Println("-----", i, "-----")
	}

END2:
	for i := 0; i < 4; i++ {
		if i == 2 { // 满足条件时，执行跳转
			break END2
		}
		fmt.Println("=====", i, "=====")
	}
}

输出结果
----- 0 -----
----- 1 -----
----- 3 -----
===== 0 =====
===== 1 =====

起始