Go語言循環判斷的使用~

 

Go 語言條件語句

　　條件語句需要開發者通過指定一個或多個條件，並通過測試條件是否為 true 來決定是否執行指定語句，並在條件為 false 的情況在執行另外的語句。

下圖展示了程序語言中條件語句的結構：

if 語句由布爾表達式后緊跟一個或多個語句組成。

語法

Go 編程語言中 if 語句的語法如下：

if 布爾表達式 { // 在布爾表達式為 true 時執行  }

　栗子~

package main

import (
    "fmt"
)

func  main()  {
    //定義局部變量
    a := 85

    //使用go中的if判斷語句
    if a > 80 {
        //滿足判斷條件，執行輸出一下內容
        fmt.Println("成績良好~，分數為:", a)
    }
}

以上代碼執行結果為：

成績良好~，分數為: 85

 

Go 語言 if...else 語句

if 語句 后可以使用可選的 else 語句, else 語句中的表達式在布爾表達式為 false 時執行。

 

語法

Go 編程語言中 if...else 語句的語法如下：

if 布爾表達式 { //判斷條件為真時候需要執行的代碼塊 } else { //判斷條件為假的時候需要執行的代碼塊 }
　
栗子~

package main

import (
    "fmt"
)

func  main()  {
    //定義局部變量
    a := 30

    if a > 40{
        //判斷條件變量a的值如果大於40，則執行下面的代碼塊，輸出大於40哦~
        fmt.Println("大於40哦~")
    }else {
        //判斷條件不滿足大於40，則執行下面的代碼塊輸出小於40哦~
        fmt.Println("小於40哦~")
    }
    //打印變量a的值
    fmt.Println("變量a的值為:",a)
}

執行結果為

小於40哦~
變量a的值為: 30

 

Go 語言循環語句

在不少實際問題中有許多具有規律性的重復操作，因此在程序中就需要重復執行某些語句，有些循環是有循環次數，有些事無限循環的，下面將會舉例說明。

語法

Go語言的For循環有3中形式，只有其中的一種使用分號。

和 C 語言的 for 一樣：

for 初始化變量;判斷條件;修正變量{}

和 C 的 while 一樣：

for 判斷條件 {}

無限循環(死循環)

for { }

for語句執行過程如下：

1.  先對變量初始化賦值
2. 判斷初始化的變量是否滿足循環的條件，如果滿足即為真，則執行循環內部的代碼塊，然后執行修正條件(遞增++或者遞減--)，然后進入第二 第三...輪循環，直到條件不滿足，循環結束！

for 循環的 range 格式可以對 slice、map、數組、字符串等進行迭代循環。格式如下：

 

for key, value := range oldMap {
    newMap[key] = value
}

 

for語句語法流程如下圖所示：

 栗子~

 

package main

import (
    "fmt"
)


func main(){
    //初始化局部變量sum，用於求和的變量
    sum := 0
    //初始化變量i為1，判斷條件為i小於等於100，修正判斷條件的是每循環一次i遞增+1
    for i := 1; i<=100; i++{
        //每一次循環都讓當前的sum值加上當前循環i的值
        sum += i
    }
    //循環結束以后100之內的所有正整數的和
    fmt.Println("100之內整數的和為:", sum)


    var i int = 15
    var j int
    //當變量j小於變量i的時候進入循環體
    for j < i {
        //修正循環體的條件，每循環一次j+1
        j++
        fmt.Println("j的值為:", j)
    }

    //初始化局部變量l1（10位的整數型數組）
    l1 := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    //循環數組
    for index,v := range l1{
        //打印數組每個索引位置上的元素
        fmt.Printf("第 %d 位的元素為: %d\n", index, v)
    }

}

以上代碼執行結果為：

100之內整數的和為: 5050
j的值為: 1
j的值為: 2
j的值為: 3
j的值為: 4
j的值為: 5
j的值為: 6
j的值為: 7
j的值為: 8
j的值為: 9
j的值為: 10
j的值為: 11
j的值為: 12
j的值為: 13
j的值為: 14
j的值為: 15
第 0 位的元素為: 1
第 1 位的元素為: 2
第 2 位的元素為: 3
第 3 位的元素為: 4
第 4 位的元素為: 5
第 5 位的元素為: 6
第 6 位的元素為: 7
第 7 位的元素為: 8
第 8 位的元素為: 9
第 9 位的元素為: 10

 

Go 語言允許用戶在循環內使用循環。接下來我們將為大家介紹嵌套循環的使用。

語法

以下為 Go 語言嵌套循環的格式：

for [判斷條件 |  ( 初始化變量; 判斷條件; 修正判斷條件的遞增或者遞減 ) | Range]
{
    for [判斷條件 |  ( 初始化變量; 判斷條件; 修正判斷條件的遞增或者遞減 ) | Range]
    {
        循環中的代碼塊;
    }
    循環外的代碼塊;
}

栗子~

以下實例使用循環嵌套來輸出 2 到 100 間的素數：

package main

import (
    "fmt"
)

func main(){
    //定義局部變量
    var  i, j int

    for i=2; i < 100; 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 是素數
11 是素數
13 是素數
17 是素數
19 是素數
23 是素數
29 是素數
31 是素數
37 是素數
41 是素數
43 是素數
47 是素數
53 是素數
59 是素數
61 是素數
67 是素數
71 是素數
73 是素數
79 是素數
83 是素數
89 是素數
97 是素數

Go 語言 break 語句 

Go 語言中 break 語句用於以下兩方面：

1. 用於循環語句中跳出循環，並開始執行循環之后的語句。
2. break在switch（開關語句）中在執行一條case后跳出語句的作用。

break 語句流程圖如下：

 

栗子~

package main

import (
    "fmt"
)

func main(){
    for i := 1;i<10;i++{
        //當i的第8次循環時候，跳出整個循環體
        if i == 8{
            fmt.Printf("for的第 %d 次循環，循環中遇到break退出整個循環體咯~",i)
            //跳出整個循環體
            break
        }
        fmt.Printf("for的第 %d 次循環.\n",i)
    }

}

以上代碼執行結果為：

for的第 1 次循環.
for的第 2 次循環.
for的第 3 次循環.
for的第 4 次循環.
for的第 5 次循環.
for的第 6 次循環.
for的第 7 次循環.
for的第 8 次循環，循環中遇到break退出整個循環體咯~

 

Go 語言 continue 語句

Go語言的continue語句有點像break語句。但是continue不是跳出整個for循環，而是跳過當前循環而執行下一次循環語句。

for循環中，執行continue語句會觸發for增量語句的執行。

栗子~

package main

import (
    "fmt"
)

func main(){

    var sum int = 0
    for i := 1; i<=100; i++ {
        //當變量i和2取余數不等於0，即代表是奇數，就跳出本輪循環執行下次循環
        if i%2 != 0 {
            //跳過本輪循環執行下一次循環
            continue
        } else {
            //當時偶數的時候，就做和的疊加
            sum += i
        }
    }
    fmt.Printf("100之內所有偶數的和為: %d", sum)
}

以上代碼執行結果為：

100之內所有偶數的和為: 2550

 

Go 語言 goto 語句

Go 語言的 goto 語句可以無條件地轉移到過程中指定的行。

goto語句通常與條件語句配合使用。可用來實現條件轉移， 構成循環，跳出循環體等功能。

但是，在結構化程序設計中一般不主張使用goto語句， 以免造成程序流程的混亂，使理解和調試程序都產生困難。

語法

goto 語法格式如下：

goto LABEL;
..
.
LABEL: 代碼段;

break 語句流程圖如下：

栗子~

package main

import (
    "fmt"
)

func main(){
    for i := 1; i<10; i++{
        //當第六次循環的時候，滿足判斷條件，執行goto
        if i == 6{
            //會直接調到后面的LABEL對應的語句，循環將不再繼續
            goto LABEL
        }else{
            fmt.Printf("for循環內的第%d次循環.\n", i)
        }
    }
    LABEL: fmt.Printf("循環到第6次咯，寶寶不要在循環了~")
    fmt.Println("我是goto下面的語句~")

}

以上代碼執行結果為：

for循環內的第1次循環.
for循環內的第2次循環.
for循環內的第3次循環.
for循環內的第4次循環.
for循環內的第5次循環.
循環到第6次咯，寶寶不要在循環了~我是goto下面的語句~

 

 

Go 語言 無限循環 語句

Go 語言的 無限循環 語句，只要你計算機不掛掉，你不手動終止程序，它可以陪你到天荒地老~~

栗子~

package main

import (
    "fmt"
)

func main(){
    //無限循環語句~~陪你到天荒地老...
    for {
        fmt.Println("在那美麗的大草原，有一群草泥馬，草泥馬 草泥馬 草泥馬~~~~")
    }

}

以上代碼執行結果為： 

在那美麗的大草原，有一群草泥馬，草泥馬 草泥馬 草泥馬~~~~
在那美麗的大草原，有一群草泥馬，草泥馬 草泥馬 草泥馬~~~~
在那美麗的大草原，有一群草泥馬，草泥馬 草泥馬 草泥馬~~~~
在那美麗的大草原，有一群草泥馬，草泥馬 草泥馬 草泥馬~~~~
在那美麗的大草原，有一群草泥馬，草泥馬 草泥馬 草泥馬~~~~
在那美麗的大草原，有一群草泥馬，草泥馬 草泥馬 草泥馬~~~~
................
................
................

 

Go 語言 switch 語句

switch 語句用於基於不同條件執行不同動作，每一個 case 分支都是唯一的，從上直下逐一測試，直到匹配為止。。

switch 語句執行的過程從上至下，直到找到匹配項，匹配項后面也不需要再加break

語法

Go 編程語言中 switch 語句的語法如

 

package main

import (
    "fmt"
)

func main(){
    //定義全局變量
    grade := "A"
    marks := 90

    //根據局部變量marks的賦值，分別給grade二次賦值
    switch marks {
        case 90:
            grade = "A"
        case 80:
            grade = "B"
        case 60,70:
            grade = "C"
        default:
            grade = "D"
        }

    //根據grade的二次賦值，選擇對應的輸出
    switch grade {
        case "A":
            fmt.Println("優秀哦~")
        case "B":
            fmt.Println("良好 良好~")
        case "C":
            fmt.Println("是不是TMD傻")
        default:
            fmt.Println("MD,腦袋糊漿糊了~")
        }
    fmt.Println("你的等級是:",grade)
}

以上代碼執行結果為： 

優秀哦~
你的等級是: A

 

Type Switch

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

Type Switch 語法 

 

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

栗子~

package main

import (
    "fmt"
)

func main() {
    var x interface{} = 100.123

    //通過反射獲取類型
    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 是 float64 型