关于golang:golang流程控制总结

41次阅读

共计 6928 个字符，预计需要花费 18 分钟才能阅读完成。

go 语言中的流程管制

本文视频教程地址：https://www.bilibili.com/vide…

go 语言中的条件

条件语句 是用来判断给定的条件是否满足 (表达式值是否为true 或者 false)，并依据判断的后果(真或假) 决定执行的语句，go 语言中的条件语句也是这样的。

go 语言中的条件语句蕴含如下几种状况

  1. if 语句：if 语句 由一个布尔表达式后紧跟一个或多个语句组成。
  2. if…else 语句: if 语句 后能够应用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。
  3. if 嵌套语句: 你能够在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。
  4. switch 语句: switch 语句用于基于不同条件执行不同动作。
  5. select 语句 : select 语句相似于 switch 语句，然而select 会随机执行一个可运行的 case。如果没有case 可运行，它将阻塞，直到有 case 可运行。

go 语言中的循环语句

go 语言中的循环只有 for 循环，去除了 while、do while 循环，应用起来更加简洁。

  1. for 循环。
  2. for range 循环。

go 语言中的流程管制关键字

  1. break
  2. continue
  3. goto

golang 中的 if 语句

go 语言 中的 if 语句 和其余语言中的相似，都是依据给定的条件表达式运算后果来，判断执行流程。

go 语言 if 语句语法

if 布尔表达式 {/* 在布尔表达式为 true 时执行 */}

留神：在 go 语言中 布尔表达式不必应用括号。

go 语言 if 语句实例演示

依据布尔值 flag 判断

import "fmt"

func test1() {
    var flag = true
    if flag {fmt.Println("flag is true")
    }
    fmt.Printf("程序运行完结")
}

func main() {test1()
}

程序运行后果

flag is true
程序运行完结

依据年龄判断是否成年

package main

import "fmt"

func test2() {
    var age = 20
    if age > 18 {fmt.Println("你是成年人")
    }
    fmt.Printf("程序运行完结")
}

func main() {test2()
}

程序运行后果

你是成年人
程序运行完结

初始变量能够申明在布尔表达式外面，留神它的作用域

func test3() {
    if age := 20; age > 18 {fmt.Println("你是成年人")
    }
    fmt.Printf("程序运行完结")
}

func main() {// test1()
    // test2()
    test3()}

程序运行后果

你是成年人
程序运行完结

留神：不能应用 0 或非 0 示意虚实

func test4() {
    var i = 1
    if i { // 编译失败
        fmt.Println("here")
    }
    fmt.Printf("程序运行完结")
}

go 语言 if 语句应用提醒：

  1. 不需应用括号将 条件蕴含起来
  2. 大括号 {} 必须存在，即便只有一行语句
  3. 左括号必须在 if 或else的同一行
  4. 在 if 之后，条件语句之前，能够增加变量初始化语句，应用 ； 进行分隔

golang 中的 if else 语句

go 语言中的 if else 语句能够依据给定条件 二选一。

go 语言的 if else 语句语法

if 布尔表达式 {/* 在布尔表达式为 true 时执行 */} else {/* 在布尔表达式为 false 时执行 */}

go 语言 if else 语句实例

比拟两个数的大小

package main

import "fmt"

func f1() {
    a := 1
    b := 2
    if a > b {fmt.Printf("\"a>b\": %v\n", "a>b")
    } else {fmt.Printf("\"a<=b\": %v\n", "a<b")
    }
}

func main() {f1()
}

判断一个数是奇数还是偶数

func f2() {
    var s int
    fmt.Println("输出一个数字：")
    fmt.Scan(&s)

    if s%2 == 0 {fmt.Print("s 是偶数 \n")
    } else {fmt.Print("s 不是偶数 \n")
    }
    fmt.Print("s 的值是：", s)
}

判断一个人是否成年

func f3() {
    age := 20
    if age >= 18 {fmt.Println("你是成年人")
    } else {fmt.Println("你还未成年")
    }
}

非凡写法，在 if 后面增加执行语句

func f4() {
    if age := 20; age >= 18 {fmt.Println("你是成年人")
    } else {fmt.Println("你还未成年")
    }
}

go 语言 if 语句应用提醒：

  1. 不需应用括号将条件蕴含起来
  2. 大括号 {} 必须存在，即便只有 一行语句
  3. 左括号 必须在 if 或else的同一行
  4. 在 if 之后，条件语句之前，能够增加变量 初始化语句 ，应用； 进行分隔

golang 中的 if else if 语句

go 语言 if 语句能够进行多重嵌套应用，进行多重判断。

go 语言中的 if else if 语法

if 布尔表达式 1 {// do something} else if 布尔表达式 2 {// do something else}else {// catch-all or default}

go 语言中的 if else if 语法实例

依据分数判断等级

func f5() {
    score := 80
    if score >= 60 && score <= 70 {fmt.Println("C")
    } else if score > 70 && score <= 90 {fmt.Println("B")
    } else {fmt.Println("A")
    }
}

程序运行后果

B

同样也能够写成这样

func f5() {
    if score := 80; score >= 60 && score <= 70 {fmt.Println("C")
    } else if score > 70 && score <= 90 {fmt.Println("B")
    } else {fmt.Println("A")
    }
}

输出星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则持续判断第二个字母

func f6() {
    //  Monday Tuesday Wednesday Thursday Friday Saturday Sunday
    var c string
    fmt.Println("输出一个字符：")
    fmt.Scan(&c)

    if c == "S" {fmt.Println("输出第二个字符：")
        fmt.Scan(&c)
        if c == "a" {fmt.Println("Saturday")
        } else if c == "u" {fmt.Println("Sunday")
        } else {fmt.Println("输出谬误")
        }
    } else if c == "F" {fmt.Println("Friday")
    } else if c == "M" {fmt.Println("Monday")
    } else if c == "T" {fmt.Println("输出第二个字符：")
        fmt.Scan(&c)
        if c == "u" {fmt.Println("Tuesday")
        } else if c == "h" {fmt.Println("Thursday")
        } else {fmt.Println("输出谬误")
        }
    } else if c == "W" {fmt.Println("Wednesday")
    } else {fmt.Println("输出谬误")
    }
}

golang 中嵌套 if 语句

go 语言 if 语句能够嵌套多级进行判断。

go 语言 if 嵌套语法

if 布尔表达式 1 {
   /* 在布尔表达式 1 为 true 时执行 */
   if 布尔表达式 2 {/* 在布尔表达式 2 为 true 时执行 */}
}

go 语言 if 嵌套实例

判断三个数的大小

package main

import "fmt"

// a>b a>c a
// b>a b>c b else c

func f1() {
    a := 100
    b := 200
    c := 3
    if a > b {
        if a > c {fmt.Println("a 最大")
        }
    } else {
        if b > c {fmt.Println("b 最大")
        } else {fmt.Println("c 最大")
        }
    }
}

func main() {f1()
}

判断男生还是女生，还有是否成年

func f2() {
    // 判断男女生及年龄
    gender := "女生"
    age := 16
    if gender == "男生" {fmt.Println("男生")
        if age > 18 {fmt.Println("成年")
        } else {fmt.Println("未成年")
        }
    } else {fmt.Println("女生")
        if age > 18 {fmt.Println("成年")
        } else {fmt.Println("未成年")
        }
    }
}

golang switch 语句

go 语言中的 switch 语句，能够非常容易的判断多个值的状况。

go 语言中 switch 语句的语法

switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

go 语言中 switch 语句实例

判断问题

func f() {
    grade := "A"
    switch grade {
    case "A":
        fmt.Println("优良")
    case "B":
        fmt.Println("良好")
    default:
        fmt.Println("个别")
    }
}

运行后果

优良

多条件匹配

go 语言 switch 语句，能够同时匹配多个条件，两头用逗号分隔，有其中一个匹配胜利即可。

func f() {
    day := 3
    switch day {
    case 1, 2, 3, 4, 5:
        fmt.Println("工作日")
    case 6, 7:
        fmt.Println("休息日")
    }
}

运行后果

工作日

case 能够是条件表达式

func f() {
    score := 90
    switch {
    case score >= 90:
        fmt.Println("享受假期")
    case score < 90 && score >= 80:
        fmt.Println("好好学习吧！")
    default:
        fmt.Println("玩命学习！")
    }
}

运行后果

享受假期

fallthrough能够能够执行满足条件的下一个case

func f3() {
    a := 100
    switch a {
    case 100:
        fmt.Println("100")
        fallthrough
    case 200:
        fmt.Println("200")
    case 300:
        fmt.Println("300")
    default:
        fmt.Println("other")
    }
}

运行后果

100
200

go 语言中 switch 语句的注意事项

  1. 反对多条件匹配
  2. 不同的 case 之间不应用 break 分隔，默认只会执行一个 case。
  3. 如果想要执行多个 case，须要应用 fallthrough 关键字，也可用 break 终止。
  4. 分支还能够应用 表达式，例如：a>10.

golang for 循环语句

go 语言中的 for 循环，只有 for 关键字，去除了像其余语言中的 while 和do while.

go 语言 for 循环语法

for 初始语句; 条件表达式; 完结语句{循环体语句}

留神：for 表达式不必加括号

go 语言 for 循环实例

循环输入 1 到 10

func f() {
    for i := 1; i <= 10; i++ {fmt.Printf("i: %v\n", i)
    }
}

运行后果

i: 1
i: 2
i: 3
i: 4
i: 5
i: 6
i: 7
i: 8
i: 9
i: 10

初始条件，能够写到里面

func f() {
    i := 1
    for ; i <= 10; i++ {fmt.Printf("i: %v\n", i)
    }
}

运行后果

i: 1
i: 2
i: 3
i: 4
i: 5
i: 6
i: 7
i: 8
i: 9
i: 10

初始条件和完结条件都能够省略

func f() {
    i := 1 // 初始条件
    for i <= 10 {fmt.Printf("i: %v\n", i)
        i++ // 完结条件
    }
}

运行后果

i: 1
i: 2
i: 3
i: 4
i: 5
i: 6
i: 7
i: 8
i: 9
i: 10

这种状况相似其余语言中的 while 循环

永真循环

func f() {
    for {fmt.Println("我始终在执行~")
    }
}

func main() {f()
}

运行后果

我始终在执行~
我始终在执行~
我始终在执行~
我始终在执行~
我始终在执行~
我始终在执行~
我始终在执行~
我始终在执行~
我始终在执行~
我始终在执行~
我始终在执行~
我始终在执行~
我始终在执行~
我始终在执行~
......

for 循环能够通过 break、goto、return、panic 语句强制退出循环。

golang for range 循环

Go 语言中能够应用 for range 遍历数组、切片、字符串、map 及通道（channel）。通过 for range 遍历的返回值有以下法则：

  1. 数组、切片、字符串返回 索引和值。
  2. map 返回键和值。
  3. 通道（channel）只返回通道内的值。

go 语言 for range 实例

循环数组

func f() {var a = [5]int{1, 2, 3, 4, 5}
    for i, v := range a {fmt.Printf("i: %d, v: %v\n", i, v)
    }
}

func main() {f()
}

运行后果

i: 0, v: 1
i: 1, v: 2
i: 2, v: 3
i: 3, v: 4
i: 4, v: 5

循环字符串

func f() {
    var s = "多课网，go 教程"
    for i, v := range s {fmt.Printf("i: %d, v: %c\n", i, v)
    }
    // %c 依照字符输入
}

func main() {f()
}

运行后果

i: 0, v: 多
i: 3, v: 课
i: 6, v: 网
i: 9, v:，i: 12, v: g
i: 13, v: o
i: 14, v: 教
i: 17, v: 程

循环切片

func f() {var s = []int{1, 2, 3, 4, 5}
    for i, v := range s {fmt.Printf("i, %d, v: %v\n", i, v)
    }
}

func main() {f()
}

循环 map

func f() {m := make(map[string]string)
    m["name"] = "tom"
    m["age"] = "20"
    m["email"] = "tom@gmail.com"
    for k, v := range m {fmt.Printf("k: %v, v: %v\n", k, v)
    }
}

func main() {f()
}

运行后果

k: email, v: tom@gmail.com
k: name, v: tom
k: age, v: 20

golang 流程管制关键字 break

break语句能够完结 for、switch 和select的代码块。

go 语言应用 break 注意事项

  1. 独自在 select 中应用 break 和不应用 break 没有啥区别。
  2. 独自在表达式 switch 语句，并且没有 fallthough，应用break 和不应用 break 没有啥区别。
  3. 独自在表达式 switch 语句，并且有 fallthough，应用break 可能终止 fallthough 前面的 case 语句的执行。
  4. 带标签的 break，能够跳出多层select/ switch 作用域。让 break 更加灵便，写法更加简略灵便，不须要应用控制变量一层一层跳出循环，没有带 break 的只能跳出以后语句块。

go 语言 break 关键字实例

跳出 for 循环

func f() {
    for i := 0; i < 10; i++ {
        if i == 5 {break // 退出循环}
        fmt.Printf("i: %v\n", i)
    }
}

func main() {f()
}

运行后果

i: 0
i: 1
i: 2
i: 3
i: 4

跳出 switch

func f() {
    i := 2
    switch i {
    case 1:
        fmt.Println("等于 1")
        break
    case 2:
        fmt.Println("等于 2")
        break
        fallthrough
    case 3:
        fmt.Println("等于 3")
        break
    default:
        fmt.Println("不关怀")
        break
    }
}
func main() {f()
}

运行后果

等于 2

正文掉 fallthrough 下面的break，运行后果

等于 2
等于 3

跳转到标签处

func f() {
MY_LABEL:
    for i := 0; i < 10; i++ {
        if i == 5 {break MY_LABEL}
        fmt.Printf("%v\n", i)
    }
    fmt.Println("end...")
}
func main() {f()
}

运行后果

0
1
2
3
4
end...

golang 关键字 continue

continue只能用在循环中，在 go 中只能用在 for 循环中，它能够终止本次循环，进行下一次循环。

在 continue语句后增加标签时，示意开始标签对应的循环。

go 语言 continue 实例

输入 1 到 10 之间的偶数

func f() {
    for i := 0; i < 10; i++ {
        if i%2 == 0 {fmt.Printf("i: %v\n", i)
        }
    }
}
func main() {f()
}

运行后果

i: 0
i: 2
i: 4
i: 6
i: 8

跳转到 label

func f() {
    // MY_LABEL:
    for i := 0; i < 5; i++ {
    MY_LABEL:
        for j := 0; j < 5; j++ {
            if i == 2 && j == 2 {continue MY_LABEL}
            fmt.Printf("i=%d,j=%d\n", i, j)
        }
    }
}
func main() {f()
}

运行后果

i=0,j=0
i=0,j=1
i=0,j=2
i=0,j=3
i=0,j=4
i=1,j=0
i=1,j=1
i=1,j=2
i=1,j=3
i=1,j=4
i=2,j=0
i=2,j=1
i=2,j=3
i=2,j=4
i=3,j=0
i=3,j=1
i=3,j=2
i=3,j=3
i=3,j=4
i=4,j=0
i=4,j=1
i=4,j=2
i=4,j=3
i=4,j=4

关注公众号学习更多 golang 技能

正文完
golang
发表至： golang
2021-12-07
 0
关于golang:手撸golang-etcd-raft协议之11
Go-语言闭包详解
关于golang:学会gin框架的参数验证之validator库看这一篇就够用了
关于golang:go变量