04go條件和迴圈

阿新 • • 發佈：2020-07-14

Go語言基礎之流程控制

流程控制是每種程式語言控制邏輯走向和執行次序的重要部分，流程控制可以說是一門語言的“經脈”。

Go語言中最常用的流程控制有if和for，而switch和goto主要是為了簡化程式碼、降低重複程式碼而生的結構，屬於擴充套件類的流程控制。

1、if else(分支結構)

if條件判斷基本寫法

if 表示式1 {
    分支1
} else if 表示式2 {
    分支2
} else{
    分支3
}

Go語言規定與if匹配的左括號{必須與if和表示式放在同一行，{放在其他位置會觸發編譯錯誤。同理，與else匹配的{也必須與else寫在同一行，else也必須與上一個if

或else if右邊的大括號在同一行。

例子：

func ifDemo2() {
	if score := 65; score >= 90 {
		fmt.Println("A")
	} else if score > 75 {
		fmt.Println("B")
	} else {
		fmt.Println("C")
	}
}

if條件判斷特殊寫法

if條件判斷還有一種特殊的寫法，可以在 if 表示式之前新增一個執行語句，再根據變數值進行判斷，舉個例子：

func ifDemo2() {
    //這裡的 score 是區域性作用域,只能夠在該if..else語句塊中使用，否則編譯器會報錯。
	if score := 65; score >= 90 {
		fmt.Println("A")
	} else if score > 75 {
		fmt.Println("B")
	} else {
		fmt.Println("C")
	}
}

2、for(迴圈結構)

Go 語言中的所有迴圈型別均可以使用for關鍵字來完成。

for迴圈的基本格式如下：

for 初始語句;條件表示式;結束語句{
    迴圈體語句
}

條件表示式返回true時迴圈體不停地進行迴圈，直到條件表示式返回false時自動退出迴圈。

func forDemo() {
	for i := 0; i < 10; i++ {
		fmt.Println(i)
	}
}

for迴圈的初始語句可以被忽略，但是初始語句後的分號必須要寫，例如：

func forDemo2() {
	i := 0
	for ; i < 10; i++ {
		fmt.Println(i)
	}
}

for迴圈的初始語句和結束語句都可以省略，例如：

func forDemo3() {
	i := 0
	for i < 10 {
		fmt.Println(i)
		i++
	}
}

這種寫法類似於其他程式語言中的while，在while後新增一個條件表示式，滿足條件表示式時持續迴圈，否則結束迴圈。

注意：Go 語言中是沒有 while 語句的，我們可以通過 for 代替。

無限迴圈

for {
    迴圈體語句
}

for迴圈可以通過break、goto、return、panic語句強制退出迴圈。

	k := 1
	for { // 這裡也等價 for ; ; {
		if k <= 10 {
			fmt.Println("ok~~", k)
		} else {
			break //break 就是跳出這個 for 迴圈
		}
		k++
	}

例子：

練習：列印 0-50 所有的偶數

for i := 0; i < 50; i++ {
	if i%2 == 0 {
		fmt.Println(i)
	}
}

練習：列印 1~100 之間所有是 9 的倍數的整數的個數及總和

count := 0
sum := 0
for i := 1; i < 100; i++ {
	if i%9 == 0 {
		sum += i
		count++
	}
}
fmt.Println("count=",count)
fmt.Println("sum=",sum)

練習：求 1+2+3+4 +...100 的和

sum := 0
for i := 0; i <= 100; i++ {
	sum += i
}
fmt.Println("sum=", sum)

練習：計算 5 的階乘 (12345 n 的階乘 12……n)

var n = 5
sum := 1

for i := 1; i <= n; i++ {
	sum *= i
}
fmt.Println("sum=", sum)

練習：列印一個矩形

for i := 1; i <= 12; i++ {
	fmt.Print("*")
	if i%4 == 0 {
		fmt.Println()
	}
}

巢狀迴圈解決這個問題

line := 4
num := 8
for i := 1; i <= line; i++ {
	for j := 0; j < num; j++ {
		fmt.Print("*")
	}
	fmt.Println()
}

練習：列印一個三角形
*
**
***
****
*****

line := 5
for i := 1; i <= line; i++ {
	for j := 0; j < i; j++ {
		fmt.Print("*")
	}
	fmt.Println()
}

練習：打印出九九乘法表

for i := 1; i <= 9; i++ {
	for j := 1; j <= i; j++ {
		fmt.Printf("%vx%v=%v \t", i, j, i*j)
	}
	fmt.Println()
}

1x1=1
2x1=2 2x2=4
3x1=3 3x2=6 3x3=9
4x1=4 4x2=8 4x3=12 4x4=16
5x1=5 5x2=10 5x3=15 5x4=20 5x5=25
6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36
7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49
8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64
9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81

3、for range(鍵值迴圈)

Go語言中可以使用for range遍歷陣列、切片、字串、map 及通道（channel）。通過for range遍歷的返回值有以下規律：

陣列、切片、字串返回索引和值。
map返回鍵和值。
通道（channel）只返回通道內的值。

str := "abc 上海"
for index, val := range str {
	fmt.Printf("index=%d, val=%c \n", index, val)
}

str := "abc 上海"
for _, val := range str {
	fmt.Printf("val=%c \n", val)
}

4、switch case

使用 switch 語句可方便的對大量的值進行條件判斷。

練習：判斷檔案型別,如果字尾名是.html 輸入 text/html, 如果字尾名.css 輸出 text/css ,如果
字尾名是.js 輸出 text/javascript
Go 語言規定每個 switch 只能有一個 default 分支。

extname := ".a"
switch extname {
	case ".html":
	fmt.Println("text/html")
	break
	case ".css":
	fmt.Println("text/css")
	break
	case ".js":
	fmt.Println("text/javascript")
	break
	default:
	fmt.Println("格式錯誤")
	break
}

Go 語言中每個 case 語句中可以不寫 break，不加 break 也不會出現穿透的現象如下例子：

extname := ".a"
switch extname {
	case ".html":
	fmt.Println("text/html")
	case ".css":
	fmt.Println("text/css")
	case ".js":
	fmt.Println("text/javascript")
	default:
	fmt.Println("格式錯誤")
}

一個分支可以有多個值，多個case值中間使用英文逗號分隔。

n := 2
switch n {
	case 1, 3, 5, 7, 9:
	fmt.Println("奇數")
	case 2, 4, 6, 8:
	fmt.Println("偶數")
	default:
	fmt.Println(n)
}

另一種寫法：

//作用域在switch裡面
switch n := 7; n {
	case 1, 3, 5, 7, 9:
	fmt.Println("奇數")
	case 2, 4, 6, 8:
	fmt.Println("偶數")
	default:
	fmt.Println(n)
}

分支還可以使用表示式，這時候switch語句後面不需要再跟判斷變數。例如：

func switchDemo4() {
	age := 30
	switch {
	case age < 25:
		fmt.Println("好好學習吧")
	case age > 25 && age < 35:
		fmt.Println("好好工作吧")
	case age > 60:
		fmt.Println("好好享受吧")
	default:
		fmt.Println("活著真好")
	}
}

`fallthrough`語法可以執行滿足條件的case的下一個case，是為了相容C語言中的case設計的。

func switchDemo5() {
	s := "a"
	switch {
	case s == "a":
		fmt.Println("a")
		fallthrough
	case s == "b":
		fmt.Println("b")
	case s == "c":
		fmt.Println("c")
	default:
		fmt.Println("...")
	}
}

輸出：

a
b

var num int = 10
switch num {
	case 10:
	fmt.Println("ok1")
	fallthrough //預設只能穿透一層
	case 20:
	fmt.Println("ok2")
	fallthrough
	case 30:
	fmt.Println("ok3")
	default:
	fmt.Println("沒有匹配到..")
}

//輸出
//ok1
//ok2
//ok3

Type Switch

switch 語句還可以被用於 type-switch 來判斷某個 interface 變數中實際儲存的變數型別。

switch x.(type){
    case type:
       statement(s);      
    case type:
       statement(s); 
    /* 你可以定義任意個數的case */
    default: /* 可選 */
       statement(s);
}

package main

import "fmt"

func main() {
   var x interface{}
     
   switch i := x.(type) {
      case nil:	  
         fmt.Printf(" x 的型別 :%T",i)                
      case int:	  
         fmt.Printf("x 是 int 型")                       
      case float64:
         fmt.Printf("x 是 float64 型")           
      case func(int) float64:
         fmt.Printf("x 是 func(int) 型")                      
      case bool, string:
         fmt.Printf("x 是 bool 或 string 型" )       
      default:
         fmt.Printf("未知型")     
   }   
}

執行結果：

x 的型別 :<nil>

5、break(跳出迴圈)

break語句可以結束for、switch和select的程式碼塊。

用於迴圈語句中跳出迴圈，並開始執行迴圈之後的語句。
break 在 switch（開關語句）中在執行一條 case 後跳出語句的作用。
在多重迴圈中，可以用標號 label 標出想 break 的迴圈

`break`語句還可以在語句後面新增標籤，表示退出某個標籤對應的程式碼塊，標籤要求必須定義在對應的`for`、`switch`和 `select`的程式碼塊上。舉個例子：

func breakDemo1() {
BREAKDEMO1:
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				break BREAKDEMO1
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
	fmt.Println("...")
}

在多重迴圈中，可以用標號 label 標出想 break 的迴圈。

package main
import "fmt"
func main() {
	lable2:
	for i := 0; i < 2; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				break lable2
			}
		fmt.Println("i j 的值", i, "-", j)
		}
	}
}

6、continue(繼續下次迴圈)

continue語句可以結束當前迴圈，開始下一次的迴圈迭代過程，僅限在for迴圈內使用。

在 `continue`語句後新增標籤時，表示開始標籤對應的迴圈。例如：

func continueDemo() {
forloop1:
	for i := 0; i < 5; i++ {
		// forloop2:
		for j := 0; j < 5; j++ {
			if i == 2 && j == 2 {
				continue forloop1
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
}

7、goto(跳轉到指定標籤)

goto語句通過標籤進行程式碼間的無條件跳轉。goto語句可以在快速跳出迴圈、避免重複退出上有一定的幫助。Go語言中使用goto語句能簡化一些程式碼的實現過程。

package main
import "fmt"
func main() {
	var n int = 30
	fmt.Println("ok1")
    if n > 20 {
		goto label1
	}
	fmt.Println("ok2")
	fmt.Println("ok3")
	fmt.Println("ok4")
	
	label1:
	fmt.Println("ok5")
	fmt.Println("ok6")
	fmt.Println("ok7")
	}

/*
輸出結果：
d:\golang\src\demo01>go run main.go
ok1
ok5
ok6
ok7
*/

例如雙層巢狀的for迴圈要退出時：

func gotoDemo1() {
	var breakFlag bool
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 設定退出標籤
				breakFlag = true
				break
			}
			fmt.Printf("%v-%v\n", i, j)
		}
		// 外層for迴圈判斷
		if breakFlag {
			break
		}
	}
}

使用goto語句能簡化程式碼：

func gotoDemo2() {
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 設定退出標籤
				goto breakTag
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
	return
	// 標籤
breakTag:
	fmt.Println("結束for迴圈")
}

統一錯誤處理

多處錯誤處理存在程式碼重複時是非常棘手的，例如：

	err := firstCheckError()
    if err != nil {
        goto onExit
    }
    err = secondCheckError()
    if err != nil {
        goto onExit
    }
    fmt.Println("done")
    return
onExit:
    fmt.Println(err)
    exitProcess()