• go语言的流程控制-if-for-switch-goto
  • 1.if-else-分支结构
    • 1.1.if-条件判断基本写法
      • 1.1.1.语法示例
      • 1.1.2.语法说明
      • 1.1.3.语法要求
    • 1.2.if-条件判断特殊写法
    • 1.3.if-条件判断的两种写法却别在哪
    • 1.4.实例演示
  • 2.for-循环结构
    • 2.1.for-循环标准语法
      • 2.1.1.语法示例
      • 2.1.2.语法说明
    • 2.2.for-循环-无限循环-死循环
    • 2.3.for...range-键值循环
    • 2.4.实例演示
  • 3.switch_case-循环语句
    • 3.1.switch-标准语法
      • 3.1.1.语法示例
      • 3.1.2.语法说明
    • 3.2.fallthrouugh-语法
    • 3.3.实例演示
  • 4.GO-语言中的标签语法
    • 4.1.break-退出循环语法
    • 4.2.goto-标签语法-跳转到指定标签
    • 4.3.break-标签语法-跳出循环
    • 4.4.conitune-标签语法-继续下次循环
    • 4.5.实例演示
  • 10.参考地址

1.if-else-分支结构

• Go 语言中最常用的流程控制有 if 和 for
• switch 和 goto 主要是为了简化代码、降低重复代码而生的结构，属于扩展类的流程控制

1.1.if-条件判断基本写法

1.1.1.语法示例

# 标准分支
if 表达式1 {
    分支1
} else if 表达式2 {
    分支2
} else{
    分支3
}

# 简化型分支
if 表达式1 {
    分支1
}

1.1.2.语法说明

如果 表达式1 的结果为 true ，执行分支1；
否则判断 表达式2，如果满足则执行分支2；
前两个表达式都不满足时，则执行分支3，也就是默认条件下执行的操作

1.1.3.语法要求

1.判断语句关键字（if，else if 或者 else ）的 左大括号{ 必须与关键字和判断表达式放在同一行，放在其他位置会触发编译错误
2.其他判断关键字（else if 和 else）必须放在上一个 判断关键字（if 或 else if）右大括号} 后面，且在同一行
3.if 判断中的其他判断关键字（else if 和 else）都是可选的，可以根据实际需要进行使用

1.2.if-条件判断特殊写法

• 可以在 if 表达式之前添加一个变量赋值语句，再根据变量值进行判断

1.3.if-条件判断的两种写法却别在哪

• 主要区别在于变量的作用域
• 标准写法，if 语句外面的变量定义可以用于多个 if 语句
• 特殊写法，if 语句里面的变量定义只能用于当前的 if 语句

1.4.实例演示

package main

import (
    "fmt"
)

// if 条件判断
func ifDemo01() { // 标准写法
    score := 65
    if score >= 90 {
        fmt.Println("A")
    } else if score > 75 {
        fmt.Println("B")
    } else {
        fmt.Println("C")
    }
}

func ifDemo02() { // 特殊写法
    if score := 65; score >= 90 {
        fmt.Println("A")
    } else if score > 75 {
        fmt.Println("B")
    } else {
        fmt.Println("C")
    }
}

// 以上两种写法的区别，变量的作用域问题 ！！！
// if 语句外面的变量定义可以用于多个 if 语句
// if 语句里面的变量定义只能用于当前的 if 语句

func main() {
    ifDemo01()
    ifDemo02()
}

2.for-循环结构

• Go 语言中的所有循环类型均可以使用for关键字来完成

2.1.for-循环标准语法

• 注意：for 循环可以通过 break、goto、return、panic 语句强制退出循环

2.1.1.语法示例

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

2.1.2.语法说明

• 条件表达式返回 true 时循环体不停地进行循环，直到条件表达式返回 false 时自动退出
• for 循环的初始语句可以被忽略，但是初始语句后的分号必须要写
• for 循环的初始语句和结束语句都可以省略

2.2.for-循环-无限循环-死循环

• 永远运行的循环

2.3.for...range-键值循环

• Go语言中可以使用 for range 遍历数组、切片、字符串、map 及通道（channel）
• 通过 for range 遍历的返回值有以下规律

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

2.4.实例演示

package main

import (
    "fmt"
)

// for 循环标准写法
func forDemo01() {
    fmt.Printf("forDemo01\n")
    for i := 0; i < 10; i++ {
        fmt.Println(i)
    }
}

// 省略初始语句的 for 循环写法
func forDemo02() {
    fmt.Printf("forDemo02\n")
    i := 0
    for ; i < 10; i++ { // 简略写法
        fmt.Println(i)
    }
}

// 省略初始语句和结束语句的 for 循环写法
func forDemo03() {
    fmt.Printf("forDemo03\n")
    i := 0
    for i < 10 { // 相当于其他语言的 while 语法
        fmt.Println(i)
        i++ // 写法相当于 i = i +1
    }
}

// 无限循环-死循环
func forDemo04() {
    for { // 啥也不写就是最简单的死循环，
        // 实际测试这个死循环只会跑满单个 CPU 内核，推测是针对多核处理器跑死循环任务做了优化
    } // 虽说如此，生产环境还是不建议测试这个死循环
}

func main() {
    forDemo01()
    forDemo02()
    forDemo03()
    forDemo04()
}

3.switch_case-循环语句

• switch 循环，相当于 if 条件判断的变种
• 使用 switch 语句可方便地对大量的值进行条件判断

3.1.switch-标准语法

3.1.1.语法示例

3.1.2.语法说明

• Go 语言规定,每个 switch 只能有一个 default 分支
• 一个分支可以有多个值，多个 case 值中间使用英文逗号分隔
• 分支可以使用表达式，这时候 switch 语句后面不需要再跟判断变量

3.2.fallthrouugh-语法

• fallthrough 语法用于执行满足条件的 case 的下一个 case 语句（仅下一个语句），是为了兼容 C语言 中的 case 设计的

3.3.实例演示

// Go 语言规定,每个 switch 只能有一个 default 分支
func switchDemo01() {
    finger := 3
    switch finger {
    case 1:
        fmt.Println("大拇指")
    case 2:
        fmt.Println("食指")
    case 3:
        fmt.Println("中指")
    case 4:
        fmt.Println("无名指")
    case 5:
        fmt.Println("小拇指")
    default:
        fmt.Println("无效的输入！")
    }
}

// 一个分支可以有多个值，多个 case 值中间使用英文逗号分隔
func switchDemo02() {
    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 switchDemo03() {
    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 switchDemo04() {
    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("...")
    }
}

func main() {
    switchDemo01()
    switchDemo02()
    switchDemo03()
    switchDemo04()
}

4.GO-语言中的标签语法

4.1.break-退出循环语法

• 可以实现跳出两层循环

4.2.goto-标签语法-跳转到指定标签

• 可以实现跳出两层循环
• goto 语句通过标签进行代码间的无条件跳转
• goto 语句可以在快速跳出循环、避免重复退出上有一定的帮助
• Go 语言中使用 goto 语句能简化一些代码的实现过程,例如双层嵌套的 for 循环退出

4.3.break-标签语法-跳出循环

• break 语句可以结束 for、switch 和 select 的代码块
• GO 语言中 break 语句还可以在语句后面添加标签，表示退出某个标签对应的代码块
• break 标签要求必须定义在对应的 for、switch 和 select 的代码块之上

4.4.conitune-标签语法-继续下次循环

• continue 语句可以结束当前循环，开始下一次的循环迭代过程，仅限在 for 循环内使用
• 在 continue 语句后添加标签时，表示开始标签对应的循环

4.5.实例演示

package main

import "fmt"

// 一般的跳出两层循环,通过自定义标签跳出循环
func gotoDemo01() {
    var breakFlag bool // 默认的初始化值 false
    for i := 0; i < 5; i++ {
        for j := 0; j < 5; j++ {
            if i == 2 && j == 2 {
                // 设置退出标签
                breakFlag = true // 修改 breakFlag 的值为 true
                break            // 跳出 for 循环
                // continue // 继续下一次循环
            }
            fmt.Printf("%v-%v\n", i, j)
        }
        // 外层 for 循环判断
        if breakFlag { // 判断 breakFlag 的值为 true ，执行后续语句
            fmt.Println("这是外层for循环")
            break
        }
    }
    fmt.Println("跳出两层循环-break通用语法")
}

// 使用 goto 简化跳出两层 for 循环的代码
// goto 语句通过标签进行代码间的无条件跳转
// goto 语句可以在快速跳出循环、避免重复退出上有一定的帮助
// Go 语言中使用 goto 语句能简化一些代码的实现过程,例如双层嵌套的 for 循环退出
func gotoDemo02() {
    for i := 0; i < 5; i++ {
        for j := 0; j < 5; j++ {
            if j == 2 {
                // 设置退出标签
                goto breakTag // GO 语言标签的引用
            }
            fmt.Printf("%v-%v\n", i, j)
        }
        fmt.Println("这是外层for循环")
    }
    return
    // 标签
breakTag: // GO 语言标签的定义
    fmt.Println("跳出两层循环-goto标签语法")
}

// GO 语言中使用 break 跳出循环
// GO 语言中 break 语句可以结束 for、switch 和 select 的代码块
// GO 语言中 break 语句还可以在语句后面添加标签，表示退出某个标签对应的代码块
// break 标签要求必须定义在对应的 for、switch 和 select 的代码块之上
func breakDemo() {
BREAKDEMO1: // GO语言：定义一个 break 标签，用的不多，执行到此会把该标签后的 for循环 跳出，相当于跳出两层 for 循环
    for i := 0; i < 5; i++ {
        for j := 0; j < 5; j++ {
            if j == 2 {
                break BREAKDEMO1 // GO 语言标签的引用
            }
            fmt.Printf("%v-%v\n", i, j)
        }
        fmt.Println("这是外层for循环")
    }
    fmt.Println("跳出两层循环-break标签语法")
}

// GO 语言中使用 continue 实现继续下次循环
// continue 语句可以结束当前循环，开始下一次的循环迭代过程，仅限在 for 循环内使用
// 在 continue 语句后添加标签时，表示开始标签对应的循环
func continueDemo() {
forloop1: /// GO语言：定义一个 continue 标签，用的不多，执行到此会跳过本次循环，并转到标签位置，继续执行后续 for 循环
    for i := 0; i < 5; i++ {
        // forloop2:
        for j := 0; j < 5; j++ {
            if i == 2 && j == 2 {
                continue forloop1 // GO 语言标签的引用
            }
            fmt.Printf("%v-%v\n", i, j)
        }
        fmt.Println("这是外层for循环")
    }
    fmt.Println("继续循环-continue标签语法")
}

func main() {
    // gotoDemo01()
    // gotoDemo02()
    // breakDemo()
    // continueDemo()
}

• 打印 99 乘法表
• 打印 200 到 300 以内的质数，只能被 1 和自己整除的整数

10.参考地址

https://www.liwenzhou.com/posts/Go/04_basic/