1、Golang 中的流程控制
Go 语言中最常用的流程控制有
if
和
for
，而
switch
和
goto
主要是为了简化代码、降低重复
代码而生的结构，属于扩展类的流程控制。
2、if else(分支结构)
if 语句 if 语句 由一个布尔表达式后紧跟一个或多个语句组成。
1.Go 编程语言中 if 语句的语法如下：
• 可省略条件表达式括号。
• 持初始化语句，可定义代码块局部变量。
• 代码块左 括号必须在条件表达式尾部。
if 布尔表达式 {
/* 在布尔表达式为 true 时执行 */
} if 在布尔表达式为 true 时，其后紧跟的语句块执行，如果为 false 则不执行。
flag := true
a := 10
if flag{
for i := 0; i < a; i++ {
fmt.Print(i)
}
}else{
fmt.Print("为假")
} *不支持三元操作符(三目运算符) "a > b ? a : b"。 package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 100
var b int = 200
/* 判断条件 */
if a == 100 {
/* if 条件语句为 true 执行 */
if b == 200 {
/* if 条件语句为 true 执行 */
fmt.Printf("a 的值为 100 ， b 的值为 200\n" )
}
}
fmt.Printf("a 值为 : %d\n", a )
fmt.Printf("b 值为 : %d\n", b )
} a 的值为 100 ， b 的值为 200
a 值为 : 100
b 值为 : 200 注意： Go 语言规定与 if 匹配的左括号 { 必须与 if 和表达式放在同一行， { 放在其他位置会触发编译错误。 同理，与 else 匹配的 { 也必须与 else 写在同一行， else 也必须与上一个 if 或else if 右边的大括号在同一行。
2、if 条件判断特殊写法
if
条件判断还有一种特殊的写法，可以在
if
表达式之前添加一个执行语句，再根据变量值
进行判断，举个例子：
if age := 21 ;age >18{
fmt.Print("成年人")
}else{
fmt.Print("未成年人")
}3 探讨上面两种写法的区别
age := 30
if age > 20 {
fmt.Println("成年人", age)
}
fmt.Println(age)//当前区域内是全局变量，在if结构体外也可以打印出来
if age := 34; age > 20 {
fmt.Println("成年人", age)
}
fmt.Println(age)//局部变量，只能在if结构体内打印出来
4、输入一个人的成绩，如果成绩大于等于90输出A，如果小于90大于75输出B,否则输出C
package main
import (
"fmt"
// "go/format"
// "go/importer"
)
func main() {
var score = 75
if score >= 90 {
fmt.Println("A")
} else if score > 75 {
fmt.Println("B")
} else {
fmt.Println("C")
}package main
import (
"fmt"
// "go/format"
// "go/importer"
)
func main() {
if score := 85; score >= 90 {
fmt.Println("A")
} else if score > 75 {
fmt.Println("B")
} else {
fmt.Println("C")
}3、if else要注意的细节
1、if{}不能省略掉
2、 { 必须紧挨着条件
2、for(循环结构)
Golang for支持三种循环方式，包括类似 while 的语法。
语法
Go语言的For循环有3中形式，只有其中的一种使用分号。
for init; condition; post { }
for condition { }
for { }
init： 一般为赋值表达式，给控制变量赋初值；
condition： 关系表达式或逻辑表达式，循环控制条件；
post： 一般为赋值表达式，给控制变量增量或减量。
for语句执行过程如下：
①先对表达式 init 赋初值；
②判别赋值表达式 init 是否满足给定 condition 条件，若其值为真，满足循环条件，则执行循环体内语句，然后执行 post，进入第二次循环，再判别 condition；否则判断 condition 的值为假，不满足条件，就终止for循环，执行循环体外语句。for 初始语句;条件表达式;结束语句{
循环体语句}
打印1-10的所有数据（三种方式，其一）
for 初始语句;条件表达式;结束语句{
循环体语句
}
for i := 1; i <= 10; i++ {
fmt.Println(i)
}for循环的执行流程
1、i := 1
2、i <= 10
3、执行花括号里面的语句
4、i++
5、i <= 10
6、执行花括号里面的语句
7、i++
8、i <= 10
打印1-10的所有数据（三种方式，其二）
for 条件 {
循环体语句
}
for 循环的初始语句和结束语句都可以省略，例如
for 循环的初始语句可以被忽略，但是初始语句后的分号必须要写
i := 1
for ; i <= 10; i++ {
fmt.Println(i)
}打印1-10的所有数据（三种方式，其三）
for {
循环体语句
}
注意：Go 语言中是没有 while 语句的，我们可以通过 for 代替
i := 1
for i <= 10 {
fmt.Println(i)
i++
}for 无限循环
for {循环体语句}
package main
import "fmt"
func main() {
i := 1
for {
if i <= 10 {
fmt.Println(i)
} else {
break //跳出循环
}
i++
}
}
for和if的练习几则
打印 0-50 所有的偶数
i := 0
count := 0
for ; i <=50; i++ {
if i%2 == 0{
count += 1
fmt.Println(i)
}
}
fmt.Printf("0-50 所有的偶数一共有%v个",count)
求 1+2+3+4 +...100 的和
i :=1
sum := 0
for ; i <= 100; i++ {
sum += i
}
fmt.Println("1到100的和为",sum)
打印 1~100 之间所有是 9 的倍数的整数的个数及总和
sum := 0
count := 0
for i := 1; i <= 100; i++ {
if i % 9 ==0{
sum += i
count++
}
}
fmt.Printf("1到100内9的倍数的整数个数为%v,总和为%v",count,sum)计算 5 的阶乘 (12345 n 的阶乘 12……n) 1*2*3*4*5
var sum = 1
for i := 1; i <= 5; i++ {
sum *= i
}
fmt.Println(sum)打印一个矩形 (for循环的嵌套)
for循环嵌套的一个执行流程
1、i=0 打印4个* 一个换行
2、i=1 打印4个* 一个换行
3、i=2 打印4个* 一个换行
4、i=3 跳出循环
var row = 3
var column = 4
for i := 0; i < row; i++ {
for j := 0; j < column; j++ {
fmt.Print("*")
}
fmt.Println("")
} 
打印一个三角形
var row = 5
for i := 1; i <= row; i++ {
for j := 1; j <= i; j++ {
fmt.Print("#")
}
fmt.Println("")
}
打印出九九乘法表
for i := 1; i <= 9; i++ {
for j := 1; j <= i; j++ {
fmt.Printf("%v*%v=%v \t", j, i, i*j)
}
fmt.Println("")
}循环语句range
for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：
for key, value := range oldMap {
newMap[key] = value
} | 1st value | 2nd value | ||
|---|---|---|---|
| string | index | s[index] | unicode, rune |
| array/slice | index | s[index] | |
| map | key | m[key] | |
| channel | element |
通过
for range 遍历的返回值有以下规律：
1. 数组、切片、字符串返回索引和值。2. map 返回键和值。3. 通道（channel）只返回通道内的值
package main
import "fmt"
func main() {
var str = "卫宫士郎"
for k, v := range str {
fmt.Printf("下标对应的key为%v,对应的value为%c\n", k, v)
}
// 使用for range来遍历一个数组
var str1 = [...]string{"宫本樱","远坂应","卫宫巨侠"}
for k, val := range str1 {
fmt.Printf("数组内下标为%v为%v\n",k,val)
}
}
可忽略不想要的返回值，或
"_"这个特殊变量。
条件语句switch
使用 switch 语句可方便地对大量的值进行条件判断。
语法
Go 编程语言中 switch 语句的语法如下：
switch var1 {
case val1:
...
case val2:
...
default:
...
}其中的default类似if判断中的else
练习：判断对应主角的servant，反馈职阶
var servant = "sabar"
if servant == "rider" {
fmt.Print("rider 骑士职阶")
}else if servant == "sabar" {
fmt.Print("sabar 圣剑职阶")
}else if servant == "archer" {
fmt.Print("archer 弓箭手职阶")
}else{
fmt.Print("目前未收录该职阶")
}1、switch case的基本使用
var servant = "archer"
switch servant {
case "sabar":
fmt.Print("sabar 圣剑职阶")
break
case "archer":
fmt.Print("archer 弓箭手职阶")
break
case "rider":
fmt.Print("rider 骑士职阶")
break
default:
fmt.Print("目前未收录该职阶")
}Go 语言规定每个 switch 只能有一个 default 分支。Go 语言中每个 case 语句中可以不写 break ， 不加 break 也不会出现穿透的现象.
2、switch case的另一种写法
switch servant := "rider"; servant {
case "sabar":
fmt.Print("sabar 圣剑职阶")
break
case "archer":
fmt.Print("archer 弓箭手职阶")
break
case "rider":
fmt.Print("rider 骑士职阶")
break
default:
fmt.Print("目前未收录该职阶")
}3、一个分支可以有多个值，多个 case 值中间使用英文逗号分隔
判断一个数是不是偶数
var n = 8
switch n {
case 1, 3, 5, 7, 9:
fmt.Println("奇数")
break //golang中break可以写也可以不写
case 2, 4, 6, 8, 10:
fmt.Println("偶数")
break
}及格不及格
var score = "D" //ABC及格 D不及格
switch score {
case "A", "B", "C":
fmt.Println("及格")
case "D":
fmt.Println("不及格")
}
// ABC及格 D不及格
switch score := "D"; score {
case "A", "B", "C":
fmt.Println("及格")
case "D":
fmt.Println("不及格")
}4、分支还可以使用表达式，这时候 switch 语句后面不需要再跟判断变量。
var age = 20
switch {
case age >= 18:
fmt.Print("大于18岁,需要全价门票")
case age < 18:
fmt.Print("小于18岁,需要半价价门票")
case age >60 :
fmt.Print("年龄过大,不建议入内")
default:
fmt.Print("免票入内")
}5、 switch 的穿透 fallthrought
fallthrough`语法可以执行满足条件的 case 的下一个 case，是为了兼容 C 语言中的 case 设计的
var age = 20
switch {
case age >= 18:
fmt.Print("我要找到你\n")
fallthrough
case age < 18:
fmt.Print("试探你眼睛\n")
fallthrough
case age >60 :
fmt.Print("心无旁骛的\n")
fallthrough
default :
fmt.Print("相拥")
}break(跳出循环)
Go
语言中
break
语句用于以下几个方面：
用于循环语句中跳出循环，并开始执行循环之后的语句。
break
在 switch（开关语句）中在执行一条 case 后跳出语句的作用
。
在多重循环中，可以用标号 label 标出想 break 的循环。
比如： 当i=3的时候跳出当前循环
for i := 1; i <= 10; i++ {
if i == 3 {
break
}
fmt.Println(i)
}
fmt.Println("继续")
for i := 0; i < 2; i++ {
for j := 0; j < 10; j++ {
if j == 3 {
break
}
fmt.Printf("i=%v j=%v\n", i, j)
}
}循环流程：外部先循环首次，然后进到内部，然后再在内部循环完毕再回外层。
for 循环中默认 break 只能跳出一层循环
2. break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用
switch servant := "rider"; servant {
case "sabar":
fmt.Print("sabar 圣剑职阶")
break
case "archer":
fmt.Print("archer 弓箭手职阶")
break
case "rider":
fmt.Print("rider 骑士职阶")
break
default:
fmt.Print("目前未收录该职阶")
}3.在多重循环中，可以用标号 label 标出想 break 的循环。
// lable1:
// for i := 0; i < 2; i++ {
// for j := 0; j < 10; j++ {
// if j == 3 {
// break lable1
// }
// fmt.Printf("i=%v j=%v\n", i, j)
// }
// }
sabar:
for i := 1; i < 8; i++ {
for j :=1 ;j<9;j++{
if j == 3{
break sabar
}
fmt.Printf("i=%v j=%v\n", i, j)
}
continue(继续下次循环)
continue 语句可以结束当前循环，开始下一次的循环迭代过程，仅限在 for 循环内使用。
for i := 1; i <= 10; i++ {
if i == 3 {
continue
}
fmt.Println(i)
} 
for i := 0; i < 2; i++ {
for j := 0; j < 5; j++ {
if j == 3 {
continue
}
fmt.Printf("i=%v j=%v\n", i, j)
}
} 
在 continue 语句后添加标签时，表示开始标签对应的循环
archer:
for i := 0; i < 2; i++ {
for j := 0; j < 5; j++ {
if j == 3 {
continue archer
}
fmt.Printf("i=%v j=%v\n", i, j)
}
}
goto(跳转到指定标签)
goto 语句通过标签进行代码间的无条件跳转。goto 语句可以在快速跳出循环、避免重复退 出上有一定的帮助。Go 语言中使用 goto 语句能简化一些代码的实现过程
var n = 30
if n > 24 {
fmt.Println("位置1")
goto sabar
}
fmt.Println("位置2")
fmt.Println("位置3")
sabar:
fmt.Println("位置4")
fmt.Println("位置5")
扫一扫
387
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
