golang 流程控制

Golang 是一种高效而现代的编程语言，其在流程控制方面提供了丰富的功能。本文将探讨 Golang 中的流程控制结构，包括条件语句、循环语句和跳转语句，以帮助读者更好地理解和应用这些结构。

条件语句

Golang 中的条件语句包括 if 语句、switch 语句和 select 语句。

1. if 语句

if 语句用于进行条件判断，语法如下：

if condition {
    statement(s)
} else if condition {
    statement(s)
} else {
    statement(s)
}

其中，condition 是一个条件表达式，用于判断真假。如果条件为真，则执行 if 后面的语句块；否则，跳过该语句块并执行下一个语句。

如果 condition 后面带有 else if 关键字，则按顺序判断每个条件表达式，执行第一个为真的语句块。如果所有条件表达式都为假，则执行 else 后面的语句块。如果没有 else 块，则条件为假时不执行任何语句。

以下是一个 if 语句的例子：

package main

import "fmt"

func main() {
    var a int = 10
    if a < 20 {
        fmt.Printf("a 小于 20
")
    }
    fmt.Printf("a 的值为 : %d
", a)
}

输出结果：

a 小于 20
a 的值为 : 10

2. switch 语句

switch 语句用于多条件判断，语法如下：

switch expression {
    case value1:
        statement(s)
    case value2:
        statement(s)
    case value3:
        statement(s)
    default:
        statement(s)
}

其中，expression 是一个表达式，用于匹配 case 子句中的常量或变量。如果匹配成功，则执行对应的语句块；否则，跳过该语句块并执行下一个 case 子句（如果存在）。

如果所有 case 子句都未匹配成功，则执行 default 后面的语句块。如果没有 default 子句，则不执行任何语句。

以下是一个 switch 语句的例子：

package main

import "fmt"

func main() {
    var grade string = "B"
    var marks int = 90

    switch marks {
        case 90:
            grade = "A"
        case 80:
            grade = "B"
        case 60, 70:
            grade = "C"
        default:
            grade = "D"
    }

    switch {
        case grade == "A" :
            fmt.Printf("优秀!
" )
        case grade == "B", grade == "C" :
            fmt.Printf("良好
" )
        case grade == "D" :
            fmt.Printf("及格
" )
        case grade == "F":
            fmt.Printf("不及格
" )
        default:
            fmt.Printf("差
" )
    }
    fmt.Printf("你的等级是 %s
", grade )
}

输出结果：

良好!
你的等级是 B

3. select 语句

select 语句用于同时监听多个通道，语法如下：

select {
    case communication clause 1:
        statement(s)
    case communication clause 2:
        statement(s)
    .............
    default:
        statement(s)
}

其中，communication clause 指的是一个通道或一个带有方向的通道操作，包括发送操作和接收操作。如果某个通道有数据可读或可写，则执行对应的语句块；否则，跳过该通道并执行下一个 communication clause。如果所有通道都没有数据可读或可写，则执行 default 后面的语句块。

以下是一个 select 语句的例子：

package main

import "fmt"

func fibonacci(c, quit chan int) {
    x, y := 0, 1
    for {
        select {
        case c <- x:
            x, y = y, x+y
        case <-quit:
            fmt.Println("quit")
            return
        }
    }
}

func main() {
    c := make(chan int)
    quit := make(chan int)
    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println(<-c)
        }
        quit <- 0
    }()
    fibonacci(c, quit)
}

输出结果：

0
1
1
2
3
5
8
13
21
34
quit

循环语句

Golang 中的循环语句包括 for 语句和 range 语句。

1. for 语句

for 语句用于循环执行一段代码，语法如下：

for init; condition; post {
    statement(s);
}

其中，init 用于何时开始循环，condition 用于判断循环是否继续，post 用于控制循环变量的操作。

以下是一个 for 语句的例子：

package main

import "fmt"

func main() {
    var b int = 15
    var a int

    for i := 0; i < 10; i++ {
        fmt.Printf("i 的值为: %d
", i)
    }

    for a < b {
        a++
        fmt.Printf("a 的值为: %d
", a)
    }
}

输出结果：

i 的值为: 0
i 的值为: 1
i 的值为: 2
i 的值为: 3
i 的值为: 4
i 的值为: 5
i 的值为: 6
i 的值为: 7
i 的值为: 8
i 的值为: 9
a 的值为: 1
a 的值为: 2
a 的值为: 3
a 的值为: 4
a 的值为: 5
a 的值为: 6
a 的值为: 7
a 的值为: 8
a 的值为: 9
a 的值为: 10
a 的值为: 11
a 的值为: 12
a 的值为: 13
a 的值为: 14
a 的值为: 15

2. range 语句

range 语句用于遍历数组、切片、通道或映射的元素，语法如下：

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

其中，key 和 value 分别表示当前元素的键和值。

以下是一个 range 语句的例子：

package main

import "fmt"

func main() {
    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }
    fmt.Println("sum:", sum)

    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }

    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s
", k, v)
    }
}

输出结果：

sum: 9
index: 1
a -> apple
b -> banana

跳转语句

Golang 中的跳转语句包括 break、continue 和 goto。

1. break 语句

break 语句用于中断循环体，语法如下：

for i := 0; i < 10; i++ {
    if i == 5 {
        break
    }
    fmt.Printf("%d ", i)
}
fmt.Println()

输出结果：

0 1 2 3 4

2. continue 语句

continue 语句用于中断当前循环体的本次迭代，语法如下：

for i := 0; i < 10; i++ {
    if i == 5 {
        continue
    }
    fmt.Printf("%d ", i)
}
fmt.Println()

输出结果：

0 1 2 3 4 6 7 8 9

3. goto 语句

goto 语句用于无条件跳转到某个代码标签（label）处执行，语法如下：

goto label;
...
label: statement

其中，label 是一个标识符，statement 是执行语句。

以下是一个 goto 语句的例子：

package main

import "fmt"

func main() {
    i := 0
Again:
    fmt.Printf("循环执行次数：%d
", i)
    i++
    if i < 10 {
        goto Again
    }
}

输出结果：

循环执行次数：0
循环执行次数：1
循环执行次数：2
循环执行次数：3
循环执行次数：4
循环执行次数：5
循环执行次数：6
循环执行次数：7
循环执行次数：8
循环执行次数：9

总结

Golang 中的流程控制结构包括条件语句、循环语句和跳转语句。条件语句包括 if、switch 和 select 语句，用于进行单条件或多条件判断。循环语句包括 for 和 range 语句，用于循环执行一段代码或遍历某个元素。跳转语句包括 break、continue 和 goto 语句，用于中断当前循环或无条件跳转到某个标签处执行。在实际编程中，需要根据需求灵活选择合适的流程控制结构来实现代码逻辑。

以上是golang 流程控制的详细内容。更多信息请关注PHP中文网其他相关文章！