流程控制語句分類：

順序結構：普通的代碼，由上而下依次執行

分支結構(if, switch)

循環結構(for)

if語句：

格式1：

if (關系表達式) {語句體; }

執行流程：

首先計算關系表達式的值

如果關系表達式的值為true就執行語句體

如果關系表達式的值為false就不執行語句體

繼續執行后面的語句內容

if語句格式2

if (關系表達式) {語句體1; } else {語句體2; }

執行流程：

首先計算關系表達式的值

如果關系表達式的值為true就執行語句體1

如果關系表達式的值為false就執行語句體2

繼續執行后面的語句內容

if語句格式3

if (關系表達式1) {語句體1; } else if (關系表達式2) {語句體2; } … else {語句體n+1; }

首先計算關系表達式1的值

如果值為true就執行語句體1；如果值為false就計算關系表達式2的值

如果值為true就執行語句體2；如果值為false就計算關系表達式3的值

…

如果沒有任何關系表達式為true，就執行語句體n+1。

演示：

定義一個在0~100之間的變量a, 判斷分數在什么范圍，90 ~ 100優秀，80 ~ 89良好，70 ~ 79中等，60 ~ 69及格，0 ~ 59請努力加油！

func main() {// 定義一個在0~100之間的變量a, 判斷分數在什么范圍，90 ~ 100優秀，80 ~ 89良好，70 ~ 79中等，60 ~ 69及格，0 ~ 59請努力加油！var a float64fmt.Println("請輸入成績：")fmt.Scan(&a)if a >= 90 && a <= 100 {fmt.Println("優秀")} else if a >= 80 && a <= 89 {fmt.Println("良好")} else if a >= 70 && a <= 79 {fmt.Println("中等")} else if a >= 60 && a <= 69 {fmt.Println("及格")} else if a >= 0 && a <= 59 {fmt.Println("有臉吃飯？")} else {fmt.Println("成績需在0~100之間")} }

if使用細節：

• 條件表達式值必須是bool類型，可省略括號，且左大括號不能另起一行
• 小心因條件匹配順序寫出死代碼

死亡代碼是指永遠不會被執行的代碼，通常用代碼覆蓋率測試進行檢查。

func main() {x := 8if x > 5 { //優先判斷，條件表達式結果為true。println("a")} else if x > 7 { // 永遠不會執行println("b")} }

盡可能減少代碼嵌套，讓正常邏輯處于相同層次。以常見的有數錯誤返回值處理為例

func check(x int) error {if x <= 0 {return errors.New("x <= 0")}return nil }func main() {x := 10if err := check(x); err == nil {x++println(x)} else {log.Fatalln(err)} }

很顯然，if塊承擔了兩種邏輯：錯誤處理和后續正常操作。基于重構原則，我們應該保持代碼塊功能的單一性。如此，if塊僅完成條件檢查和錯誤處理，相關正常邏輯保持在同一層次。當有人試圖通過 閱讀這段代碼來獲知邏輯流程時，完全可忽略if塊細節。同時，單一功能可提升代碼可維 護性，更利于拆分重構

func main() {x := 10if err := check(x); err != nil {log.Fatalln(err)}x++println(x) }

對于某些過于復雜的組合條件，建議將其重構為函數

func main() {s := "9"if n, err := strconv.ParseInt(s, 10, 64); err != nil || n < 0 || n > 10 || n%2 != 0 {log.Fatalln("invalid number")}println("ok") }

函數調用雖然有一些性能損失，可卻讓主流程變得更加清爽。況且，條件語句獨立之后, 更易于測試，同樣會改善代碼可維護性

func check(s string) error {n, err := strconv.ParseInt(s, 10, 64)if err != nil || n < 0 || n > 10 || n%2 != 0 {return errors.New("invalid number")}return nil } func main() {s := "9"if err := check(s); err != nil {log.Fatalln(err)}println("ok") }

switch語句：

• go語言中的switch無須執行break，但是默認在每個case最后都有break，case執行完畢后自動跳出Switch。如需要貫通后續的case須使用fallthrough強制執行后面的case代碼
• 相鄰的空case不構成多條件匹配
• 不能出現重復的case常量值

格式:

switch (表達式) {case 1:語句體1case 2:語句體2...default:語句體n+1}

執行流程:

• 首先計算出表達式的值
• 其次，和case依次比較，一旦有對應的值，就會執行相應的語句，在執行的過程中，遇到break就會結束。
• 最后，如果所有的case都和表達式的值不匹配，就會執行default語句體部分，然后程序結束掉。 所以建議將default放在末尾

演示：

func switchDemo() {// 定義一個在0~100之間的變量a, 判斷分數在什么范圍，90 ~ 100優秀，80 ~ 89良好，70 ~ 79中等，60 ~ 69及格，0 ~ 59請努力加油！var score float64fmt.Println("請輸入成績：")fmt.Scan(&score)switch {case score >= 90 && score <= 100:fmt.Println("優秀")case score >= 80 && score <= 89:fmt.Println("良好")case score >= 70 && score <= 79:fmt.Println("中等")case score >= 60 && score <= 69:fmt.Println("及格")case score >= 0 && score <= 59:fmt.Println("有臉吃飯？")default:fmt.Println("成績必須在0~100之間")} }

fallthrough必須放在case塊結尾

func main() {switch x := 5; x {default:println(x)case 5:x += 10println(x)fallthrough //繼續執行下一case,但不再匹配條件表達式。case 6:x += 20println(x)//fallthrough //如果在此繼續fallthrough,不會執行default，完全按源碼順序。//導致“cannot fallthrough final case in switch”錯誤。} }

switch還被用來替換if語句。被省略的switch條件表達式默認值為true，繼而與case比較表達式結果匹配

func main() {switch x := 5; { // 相當于"switch x := 5; true { ... }"°case x > 5:println("a")case x > 0 && x <= 5: // 多條件是 OR 關系，不能寫成“case x > 0, x <= 5”。println("b")default:println("z")} }

for循環：

循環語句可以在滿足循環條件的情況下，反復執行某一段代碼，這段被重復執行的代碼被稱為循環體語句，當反復執行這個循環體時，需要在合適的時候把循環判斷條件修改為false，從而結束循環，否則循環將一直執行下去，形成死循環。

• range和fori循環中的局部變量都會被重復使用

格式

for (初始化語句;條件判斷語句;條件控制語句) {循環體語句; }// 三種for定義格式：func main() {for i := 0; i < 3; i++ {}//初始化表達式支持函數調用或定義局部變量。x := 3for x < 10 { // 相當于"while x > 0 {}” 或 “for ; x < 10 ; {}”。x++}for { // 死循環，相當于"while true {}” 或 “for true {}”。循環體語句} }

格式解釋：

• 初始化語句： 用于表示循環開啟時的起始狀態，簡單說就是循環開始的時候什么樣
• 條件判斷語句：用于表示循環反復執行的條件，簡單說就是判斷循環是否能一直執行下去
• 循環體語句： 用于表示循環反復執行的內容，簡單說就是循環反復執行的事情\
• 條件控制語句：用于表示循環執行中每次變化的內容，簡單說就是控制循環是否能執行下去

執行流程

執行初始化語句

執行條件判斷語句，看其結果是true還是false=
如果是false，循環結束
如果是true，繼續執行

執行循環體語句

執行條件控制語句

回到2繼續

求1-100之間的偶數和，并把求和結果在控制臺輸出

func forDemo() {var sum intfor i := 0; i <= 100; i++ {if i%2 == 0 {sum += i}}fmt.Println(sum) } // 這種方式就+1了，每次直接加2，不需要if判斷 func forDemo2() {var sum intfor i := 2; i <= 100; i += 2 {sum += i}fmt.Println(sum) }

range

• range本質是一個函數，在使用的時候可以加括號使用
• 修改range得到后的value不影響原切片/數組的數據，其實就相當于修改的是個副本，和原來的是無關，但是在range循環里打印的話還是副本的內容
• range和fori循環中的局部變量都會被重復使用

range 關鍵字用于

• for循環中迭代數組(array)、切片(slice)、鏈表(channel)或集合(map)的元素
• 在數組和切片中它返回元素的索引值
• 在集合中返回 key-value 對的 key 值

演示：通過參數列表傳遞多個參數，使用range獲取數據

func main() {//Demo03(1, 2, 3, 4, 5)//Demo04(1, 2, 3, 4, 5)Demo05(1, 2, 3, 4, 5) }// a代表索引 v代表數據func Demo03(num ...int) {for a, v := range num {fmt.Print("a = ", a, " ")fmt.Println("v = ", v)} }// 如果只寫一個變量，取出的是索引func Demo04(num ...int) {for v := range num {//fmt.Print("a = ", a, " ")fmt.Println("v = ", v)} }// 可以把a使用_代替，表示是一個匿名變量，匿名變量不會保存具體的數據，就可以用v取出數據func Demo05(num ...int) {for _, v := range num {//fmt.Print("a = ", a, " ")fmt.Println("v = ", v)} }

range會復制目標數據，受直接影響的是array，可改用*array或slice類型，相關數據類型中，string、slice基本結構是個很小的struct，而map、channel是指針封裝，復制成本都很小，不需專門優化

func main() {data := [3]int{10, 20, 30}for i, x := range data { // 從data復制品中取值if i == 0 {data[0] += 100data[1] += 200data[2] += 300}fmt.Printf("x: %d, data: %d\n", x, data[i])}for i, x := range data[:] { // 僅復制slice,不包括底層arrayif i == 0 {data[0] += 100data[1] += 200data[2] += 300}fmt.Printf("x: %d, data: %d\n", x, data[i])} }

輸出：

x: 10, data: 110 x: 20, data: 220 x: 30, data: 330 x: 110, data: 210 x: 420, data: 420 x: 630, data: 630

跳轉控制語句：

• 跳轉控制語句（break）:滿足條件后，終止整個語句開，break語句可以用在switch、for中進行使用

• 跳轉控制語句（continue）:滿足條件后，跳過本次循環，繼續下次循環，基于條件控制, 在循環內部使用，for可以用
  注意： continue只能在循環中進行使用！
• 跳轉控制語句（return）:表示終止函數
• 跳轉控制語句（goto）:轉移到指定的行，goto一般配合條件判斷使用，可以用來做條件轉移，跳出循環等操作

標號方式跳出：

func forDemo() {goto lable // 要跳過的代碼前要跳過的代碼lable://要跳過的代碼后的位 }// 循環嵌套就可以用了 func forDemo() { label:for i := 0; i < 3; i++ {for j := 0; j < 2; j++ {if j == 1 {break label}fmt.Println(i)}}fmt.Println("跳出來了嗎") }

演示：

func forDemo3() {for i := 1; i <= 5; i++ {if i == 3 {break}fmt.Println(i) // 結果是1、2 break會直接跳出for循環} }func forDemo4() {for i := 1; i <= 5; i++ {if i == 2 {continue}fmt.Println(i) // 結果是1、3、4、5 continue會跳過2，執行后面的} }func forDemo5() {return // 結束函數for i := 1; i <= 5; i++ {if i == 3 {break}return // 結束循環fmt.Println("走我了嗎")fmt.Println(i)} }func forDemo6() {goto label // 跳過123，執行45fmt.Println(1)fmt.Println(2)fmt.Println(3) label:fmt.Println(4)fmt.Println(5) }

循環嵌套：

循環嵌套就是在一個循環體里面嵌入另一個循環。

打印乘法口訣表案例：

func forDemo6() {for i := 1; i <= 9; i++ { // 外循環控制行for j := 1; j <= i; j++ { // 內循環控制列fmt.Printf("%d*%d=%d ", j, i, j*1)}fmt.Print("\n")} }

輸出結果：

1*1=1 1*2=1 2*2=2 1*3=1 2*3=2 3*3=3 1*4=1 2*4=2 3*4=3 4*4=4 1*5=1 2*5=2 3*5=3 4*5=4 5*5=5 1*6=1 2*6=2 3*6=3 4*6=4 5*6=5 6*6=6 1*7=1 2*7=2 3*7=3 4*7=4 5*7=5 6*7=6 7*7=7 1*8=1 2*8=2 3*8=3 4*8=4 5*8=5 6*8=6 7*8=7 8*8=8 1*9=1 2*9=2 3*9=3 4*9=4 5*9=5 6*9=6 7*9=7 8*9=8 9*9=9

總結

以上是生活随笔為你收集整理的Golang——流程控制语句、跳转控制语句细节的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。