Golang基础-3

Go语言基础

介绍

基础

1. 条件语句
2. 选择语句
3. 循环语句
4. goto关键字

介绍

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

基础

1. 条件语句

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

package mainimport "fmt"func main() {var a int = 16// 单分支，大括号必须存在，Go语言格式严格if a == 16 {fmt.Println("a == 16")}// 双分支a = 20if a != 20 {fmt.Println("a != 20")} else {fmt.Println("a == 20")}// 多分支，else if 分支任意数量、最后的 else 可选a = 40if 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 = 30if s := 16; s == a {fmt.Println("s == a")} else {fmt.Println("s != a")}// 分支嵌套，可任意嵌套，实际开发中不要嵌套太多层，嵌套太多层的代码需要优化设计a = 80if 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... :语句块1case 值3, 值4... :语句块2...default : 语句块
}

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

package mainimport "fmt"func main() {var a int = 16var 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 mainimport "fmt"func main() {var a int = 20// switch后边自定义局部变量switch {case a == 20:fmt.Println("a == 20")default:fmt.Println(a)}
}

输出结果：a == 20

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

package mainimport "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 mainimport "fmt"func main() {var a int = 20// case 分支使用 fallthrough 穿透switch {case a == 20:fmt.Println("a == 20")fallthroughcase a != 20:fmt.Println("a != 20")default:fmt.Println(a)}
}

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

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

package mainimport "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 mainimport "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 = 0var i int = 1for ; i <= 100; i++ {sum += i}fmt.Println("2 sum: ", sum)// for 省略初始化因子、迭代因子，类似 while 循环sum = 0i = 1for i <= 100 {sum += ii++}fmt.Println("3 sum: ", sum)// 无限 for 循环sum = 0i = 1for {if i <= 100 {sum += i} else { // i > 100break // 注意此处使用 break 跳出 for 循环}i++}fmt.Println("4 sum: ", sum)
}

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

package mainimport "fmt"func main() {// for-rangevar 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 mainimport "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 mainimport "fmt"func main() {for i := 0; i < 4; i++ {if i == 2 { // 满足条件时跳出 for 循环break}fmt.Println(i)}
}

输出结果
0
1

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

package mainimport "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 mainimport "fmt"func main() {fmt.Println("-----1-----")fmt.Println("-----2-----")fmt.Println("-----3-----")goto ENDfmt.Println("-----4-----")fmt.Println("-----5-----")
END:fmt.Println("-----6-----")
}

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

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

package mainimport "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, "=====")}
}