共计 4045 个字符,预计需要花费 11 分钟才能阅读完成。
流程构造就是指程序逻辑到底怎么执行,进而言之,程序执行逻辑的程序。家喻户晓,程序整体都是自上由下执行的,但有的时候,又不仅仅是从上往下执行那么简略,大体上,Go lang 程序的流程控制结构一共有三种:程序构造,抉择构造,循环构造。程序构造:从上向下,逐行执行;抉择构造:条件满足,某些代码才会执行,0- 1 次;循环构造:条件满足,某些代码会被重复的执行屡次,0- N 次
抉择构造之条件判断 if/else
市面上的语言都有 if/else 逻辑,逻辑非常简单,只有满足条件,就会执行条件代码块的逻辑:
if 布尔表达式 {/* 在布尔表达式为 true 时执行 */}
if 布尔表达式 {/* 在布尔表达式为 true 时执行 */} else {/* 在布尔表达式为 false 时执行 */}
if 布尔表达式 1 {/* 在布尔表达式 1 为 true 时执行 */} else if 布尔表达式 2{/* 在布尔表达式 1 为 false , 布尔表达式 2 为 true 时执行 */} else{/* 在下面两个布尔表达式都为 false 时,执行 */}
具体逻辑:
package main
import "fmt"
func main() {
var a int = 1
/* 应用 if 语句判断布尔表达式 */
if a < 20 {
/* 如果条件为 true 则执行以下语句 */
fmt.Printf("a 小于 20\n")
}
fmt.Printf("a 的值为 : %d\n", a)
}
程序返回:
a 小于 20
a 的值为 : 1
须要留神的是,条件变量类型要统一能力比拟。
除此之外,if 还能够在判断之前执行逻辑:
package main
import ("fmt")
func main() {
if num := 10; num%2 == 0 { //checks if number is even
fmt.Println(num, "is even")
} else {fmt.Println(num, "is odd")
}
}
程序返回:
10 is even
也就是说,当判断变量 num 对 2 取余是否等于 0 之前,咱们能够先给 num 进行赋值操作。
同时 if/else 也反对多分支判断:
package main
import ("fmt")
func main() {
score := 88
if score >= 90 {fmt.Println("问题等级为 A")
} else if score >= 80 {fmt.Println("问题等级为 B")
} else if score >= 70 {fmt.Println("问题等级为 C")
} else if score >= 60 {fmt.Println("问题等级为 D")
} else {fmt.Println("问题等级为 E 问题不及格")
}
}
程序返回:
问题等级为 B
这里程序依据变量的值而抉择执行不同的分支代码,但须要留神的是,Go lang 对于 {和} 的地位有严格的要求,它要求 else if (或 else) 和两边的花括号,必须在同一行。即便在 {和} 之间只有一条语句,这两个花括号也是不能省略的。
抉择构造之抉择判断 switch
switch 关键字是一个条件语句,它计算表达式并将其与可能匹配的列表进行比拟,并依据匹配执行代码块。它能够被了解为用一种普适的形式来写多个 if else 判断子句。
switch 语句用于基于不同条件执行不同动作,每一个 case 分支都是惟一的,从上直下逐个测试,直到匹配为止。switch 语句执行的过程从上至下,直到找到匹配项,匹配项前面也不须要再加 break。
说白了就是,每一个 case 都默认主动 break,执行完了一个,switch 逻辑也就完结了,不会程序执行别的 case,然而能够应用 fallthrough 强制执行前面的 case 代码:
package main
import "fmt"
func main() {
/* 定义局部变量 */
var grade string = "B"
var marks int = 40
switch marks {
case 90:
grade = "A"
case 80:
grade = "B"
case 50, 60, 70:
grade = "C" //case 后能够由多个数值
default:
grade = "D"
}
switch {
case grade == "A":
fmt.Printf("A\n")
case grade == "B", grade == "C":
fmt.Printf("B\n")
case grade == "D":
fmt.Printf("D\n")
case grade == "F":
fmt.Printf("F\n")
default:
fmt.Printf("low\n")
}
fmt.Printf("你的等级是 %s\n", grade)
}
程序返回:
D
你的等级是 D
这里咱们先通过 switch 对 marks 变量进行值判断,在 case 分支里赋值 grade 变量,随后又在 switch 逻辑中对 grade 做恒等判断,而后输入。
假如须要贯通后续的 case,就增加 fallthrough 关键字:
package main
import ("fmt")
func main() {
switch x := 5; x {
default:
fmt.Println(x)
case 5:
x += 10
fmt.Println(x)
fallthrough
case 6:
x += 20
fmt.Println(x)
}
}
这里首先进入 case5 逻辑,x 通过运算后变为 15,随后贯通进入下一个逻辑,x += 20 逻辑,变为 35。
程序返回:
15
35
须要留神的是,fallthrough 应该是某个 case 的最初一行。如果它呈现在两头的某个中央,编译器就会抛出谬误。
循环构造之遍历 for
for 关键字能够用来反复执行某一段代码,在 Python 中,遍历形式有三种:for、while 和 do while。然而 Go lang 只为咱们提供了一种:for:
package main
import ("fmt")
func main() {
num := 1
for num < 3 {fmt.Println(num)
num++
}
}
程序返回:
1
2
这里是但条件循环,如果满足条件,for 代码块的逻辑会重置执行。
咱们还能够为遍历增加额定的表达式逻辑,比方初始化控制变量,在整个循环生命周期内,只执行一次;设置循环管制条件,该表达式值为 true 时循环,值为 false 时完结循环;每次循环完都会执行此表达式,能够利用其让控制变量增量或减量:
package main
import ("fmt")
func main() {
for num := 0; num < 4; num++ {fmt.Println(num)
}
}
程序返回:
0
1
2
3
须要留神的是,在 for 关键字中申明的变量,也只在 for 的代码块中无效,因为和 Python 不同,go lang 有严格的块作用域限度。
在 Go lang 中遍历一个可迭代的对象个别应用 for-range 语句实现,其中 range 前面能够接数组、切片、字符串等,range 会返回两个值,第一个是索引值,第二个是数据值:
package main
import ("fmt")
func main() {
str := "123456789"
for index, value := range str {fmt.Printf("index %d, value %c\n", index, value)
}
}
程序返回:
index 0, value 1
index 1, value 2
index 2, value 3
index 3, value 4
index 4, value 5
index 5, value 6
index 6, value 7
index 7, value 8
index 8, value 9
如果 for 关键字前面没有表单式,就是死循环:
package main
import ("fmt")
func main() {
num := 1
for {fmt.Println(num)
num++
if num > 3 {break}
}
}
程序返回:
1
2
3
是的,咱们当然能够应用 break 关键字来中断循环。
但须要留神的是,break 只能终端以后循环,不能终端内部循环:
package main
import "fmt"
func main() {
/* 定义局部变量 */
var i, j int
for i = 2; i < 10; i++ {for j = 2; j <= (i / j); j++ {
if i%j == 0 {break // 如果发现因子,则不是素数}
}
if j > (i / j) {fmt.Printf("%d 是素数 \n", i)
}
}
}
程序返回:
2 是素数
3 是素数
5 是素数
7 是素数
和 Python 一样,Go lang 也具备 continue 关键字,continue 语句用来跳出 for 循环中的以后循环:
package main
import "fmt"
func main() {
for num := 1; num <= 10; num++ {
if num%2 == 0 {continue}
fmt.Println(num)
}
}
程序返回:
1
3
5
7
9
在 continue 语句后的所有的 for 循环语句都不会在本次循环中执行,执行完 continue 语句后将会继续执行一下次循环。这样咱们就能够跳过偶数,间接打印出 10 以内的奇数。
goto 无条件跳转
应用 goto 关键字能够间接跳到下一步要执行的标签代码:
package main
import "fmt"
func main() {
for x := 0; x < 10; x++ {
for y := 0; y < 10; y++ {
if y == 2 {
// 跳转到标签
goto breakHere
}
}
}
// 手动返回, 防止执行进入标签
return
// 标签
breakHere:
fmt.Println("done")
}
程序返回:
done
须要留神的是,goto 关键字与标签之间不能有变量申明,否则编译谬误。
结语
和 Python 和 Ruby 相比,整体上,在流程构造管制环节,Go lang 体现出了极大的克服,语法上删繁就简,把动静语言那些俯首听命的语法糖压抑成行文工整的诗,这样的益处是对初学者极为敌对,没有太多标准须要记忆,大道至简,大巧不工。咱们能够吐槽它没有 while 或者是 do while,亦或者是 lambda 表达式等能够炫技的资本,但,那又如何呢?就像乔帮主在聚贤庄力战群雄,大杀四方,所倚重的不过是一套普普通通的太祖长拳,Go lang 亦如此,求实胜过炫技,简略未必一般。