Go语言基础
介绍
基础
介绍
- 本文介绍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 =====
起始
