1.条件判断(if)
1.1 if
1.语法结构
if 布尔表达式 {
// 布尔表达式为true时执行
}2. 使用
a := 10
if a > 3{
fmt.Println("a > 3 为true")
}1.2 if...else
1.语法结构
if 布尔表达式 {
// 布尔表达式为true时执行
} else {
// 布尔表达式为false时执行
}2.使用
在if之后，条件语句之前，可以添加变量初始化语句，使用“;”进行分隔。
if a := 10; a > 3{
fmt.Println("a > 3 为true时,执行！")
} else {
fmt.Println("a > 3 为false时,执行！")
}1.3 if...else if...else
1.语法结构
if 布尔表达式1 {
// 布尔表达式1为true时执行
} else if (布尔表达式2) {
// 布尔表达式2为true时执行
} else {
// 布尔表达式1和2都为false时执行
}2.使用
package main
import "fmt"
func main() {
useIf(5)
useIf(14)
useIf(23)
useIf(42)
}
func useIf(a int) {
if a <= 10 {
fmt.Printf("a: %d, a <= 10\n",a)
} else if a > 10 && a <= 20 {
fmt.Printf("a: %d, a > 10 && a <= 20 \n",a)
} else if a>20 && a <= 30 {
fmt.Printf("a: %d, a > 20 && a <= 30 \n",a)
} else {
fmt.Printf("a:%d, a > 30\n",a)
}
}
/* 输出:
a: 5, a <= 10
a: 14, a > 10 && a <= 20
a: 23, a > 20 && a <= 30
a:42, a > 30
*/1.4 if嵌套
1.语法结构
if 布尔表达式A {
if 布尔表达式B {
// 布尔表达式A和布尔表达式B都为true时执行!
}
}2.使用
a := 7
if a > 5 {
if a <=7 {
fmt.Println("执行！")
}
}1.5 注意事项
在if语句的使用过程中，应注意以下细节。
- 不需使用括号将条件包含起来。
- 大括号
{}必须存在，即使只有一行语句。 - 左括号必须在if或else的同一行。
- 在
if之后，条件语句之前，可以添加变量初始化语句，使用“;”进行分隔。
2. 分支选择(switch)
Go里面switch默认相当于每个case最后带有break，匹配成功后不会自动向下执行其他case，而是跳出整个switch, 但是可以使用fallthrough强制执行后面的case代码
2.1 基本写法
1. 语法结构
switch var1 {
case "A":
fmt.Println("满足A！")
case "B":
fmt.Println("满足B！")
default:
fmt.Println("A、B都不满足！")
}2. 使用
package main
import "fmt"
func main() {
useSwitch("A")
useSwitch("B")
useSwitch("C")
useSwitch("D")
}
func useSwitch(a string) {
switch a {
case "A":
fmt.Println(a + ":优秀")
case "B":
fmt.Println(a + ":中等")
case "C":
fmt.Println(a + ":及格")
default:
fmt.Println(a + ":不及格")
}
}
/** 输出:
A:优秀
B:中等
C:及格
D:不及格
*/2.2 一支多值
1. 语法结构
switch var1 {
case "A","A1","A2":
fmt.Println("满足A,A1,A2中的一个！")
case "B","B1","B2":
fmt.Println("满足B,B1,B2中的一个！")
default:
fmt.Println("以上条件都不满足！")
}2.使用
package main
import "fmt"
func main() {
useManyValSwitch("小花")
useManyValSwitch("小明")
useManyValSwitch("太监总管")
}
func useManyValSwitch(a string) {
switch a {
case "小花","小丽","小美" :
fmt.Println(a + "是女生！")
case "小明","小虎" :
fmt.Println(a + "是男生！")
default:
fmt.Println(a + "不男不女!")
}
}
/** 输出
小花是女生！
小明是男生！
太监总管不男不女!
*/2.3 表达式分支
1.语法结构
switch {
case a < A:
fmt.Println("a小于A！")
case A <=a && a < B
fmt.Println("a大于A,并且小于B！")
default:
fmt.Println("a大于等于A,并且小于B！")
}switch后面省略不写，默认相当于switch true
2.使用
package main
import "fmt"
func main() {
useExpressionSwitch(5)
useExpressionSwitch(15)
useExpressionSwitch(25)
}
func useExpressionSwitch(a int) {
switch {
case a >= 1 && a < 10:
fmt.Printf(" a = %d, a >= 1 && a < 10 \n",a)
case a >= 10 && a < 20:
fmt.Printf(" a = %d, a >= 10 && a < 20 \n",a)
case a >= 20 && a < 30:
fmt.Printf(" a = %d, a >= 20 && a < 30 \n",a)
}
}
/**输出:
a = 5, a >= 1 && a < 10
a = 15, a >= 10 && a < 20
a = 25, a >= 20 && a < 30
*/3.循环(for)
for是Go语言中唯一的循环语句，Go没有while、do...while、foreach循环。按语法结构来分，Go语言的for循环有4种形式
语法结构:
for关键字后有3个表达式——基本for循环语法结构。其语法结构如下所示:
for 初始化语句; 条件表达式; 结束语法 {
...
}使用说明:
- 先执行初始语句，对控制变量赋初始值。初始语句只执行一次；
- 初始语句、条件表达式和结束语句，都是可选的。可写可不写;
- 条件表达式是控制循环与否的开关:
如果表达式为true，则循环继续；否则结束循环; - 省略条件表达式默认形成无限循环;
- 左括号必须和
for关键字在同一行; - 初始语句可以省略不写，但是初始语句之后的分号必须要写
3.1 基础使用(表达都不省略)
// 基础for循环使用
func main() {
var sum int
for i := 1; i <= 100; i++ {
sum += is
}
fmt.Printf("1到100的数字相加结果: %d " ,sum)
}3.2 省略初始语句
func main() {
sum := 0
i := 1
for ; i<= 100 ; i++ {
sum += i
}
fmt.Printf("1到100的数字相加结果: %d " ,sum)
}初始语句可以省略不写，但是初始语句之后的分号必须要写。
3.3 省略初始和条件表达式
func mai3n() {
sum := 0
i := 0
for ; ; i++ {
if i > 100 {
break
}
sum += i
}
fmt.Printf("1到100的数字相加结果: %d " ,sum)
}条件表达式（condition）是控制循环与否的开关：如果表达式为true，则循环继续；否则结束循环。条件表达式可以省略不写，之后的分号必须要写。省略条件表达式默认形成无限循环。
3.4 只有条件表达式
func main() {
sum := 0
i := 1
for i <= 100 {
sum += i
i ++
}
fmt.Printf("1到100的数字相加结果: %d " ,sum)
}3.5 无限循环
func mai3n() {
sum := 0
i := 1
for {
// 不满足则一直循环
if i > 100 {
break
}
sum += i
i++
}
fmt.Printf("1到100的数字相加结果: %d " ,sum)
}3.6 嵌套循环
// 乘法表
func main() {
for i :=1 ; i< 9; i++ {
for j :=1; j <= i; j++ {
fmt.Printf("%d * %d = %d ",i,j,i * j)
}
fmt.Println()
}
}4 . 遍历( for ... range)
for循环的range格式对string、slice、array、map、channel等进行迭代循环。array、slice、string返回索引和值；map返回键和值；channel只返回通道内的值。其语法结构如下所示:
for key,value := range data {
....
}4.1 遍历字符串
package main
import "fmt"
func main() {
s := "Go，您好！"
ForByStr(s)
ForByByte(s)
ForByRune(s)
}
// 遍历字符串
func ForByStr(str string) {
for k,v := range str {
fmt.Printf("遍历字符串 -> k:%v , v:%c \n",k,v)
}
}
// 遍历字节
func ForByByte(string2 string) {
for k,v := range []byte(string2){
fmt.Printf("遍历字节 -> k:%v , v:%x \n",k,v)
}
}
// 遍历字符
func ForByRune(string2 string) {
for k,v := range []rune(string2) {
fmt.Printf("遍历字符 -> k:%v , v:%c \n",k,v)
}
}如果字符串涉及中文，遍历字符推荐使用rune。因为一个byte存不下一个汉语文字的unicode值。
4.2 遍历数组
func main() {
arr := [5]string{"hello","word","欢","迎","!"}
fmt.Printf("arr 类型:%T, 值:%v \n",arr,arr)
for key, val := range arr{
fmt.Printf("key: %d, value: %s \n",key,val)
}
}4.3 遍历切片
func main() {
slice := []int{1,3,5,7,9,11}
// key 可以省略不写
for _,val := range slice {
fmt.Printf("值: %d \n",val)
}
}4.4 遍历Map
func main() {
grades := map[string]int{
"张三":60,
"小米":70,
"小明":88,
}
for name, grade := range grades {
fmt.Printf("姓名: %s 成绩: %d \n", name,grade)
}
}5.循环控制语句
5.1 break
跳出循环体。break语句用于终止当前正在执行的for循环，并开始执行循环之后的语句。
使用
func main() {
for i := 1; i < 5 ; i++ {
// i > 3后跳出循环
if i > 3 {
break
}
fmt.Printf("i = %d \n" , i)
}
}
/** 输出
i = 1
i = 2
i = 3
*/5.2 continue
Go语言的continue语句有点像break语句。但是continue不是跳出循环，而是跳过当前循环，执行下一次循环语句。
使用
func main() {
for i := 1; i < 5 ; i++ {
if i == 3 {
// 跳过i=3这个循环
continue
}
fmt.Printf("i = %d \n" , i)
}
}
/** 输出:
i = 1
i = 2
i = 4
*/5.3 goto
func main() {
for i := 1; i < 5 ; i++ {
if i == 3 {
// 当i=3时，重新循环
goto RESET
}
fmt.Printf("i = %d \n" , i)
}
fmt.Println("这里将不会打印出来.....")
RESET:
fmt.Println("程序从这里开始执行.....")
}
/** 输出
i = 1
i = 2
程序从这里开始执行.....
*/微信搜索关注【猿码记】查看更多文章。
本文由mdnice多平台发布