09-Go语言流程控制-指趣学院

Go语言流程控制基本概念

• Go语言流程控制和C语言一样, 也有三大流程控制结构
  • 顺序结构(默认结构)
  • 选择结构(if / switch)
  • 循环结构(for)

---

选择结构if

• 和C语言不同的的是
  • 条件表达式的值必须是布尔类型(Go语言中没有非零即真的概念)
  • 条件表达式前面可以添加初始化语句
  • 不需要编写圆括号
  • 左大括号必须和条件语句在同一行
• 第一种格式:
  • 条件表达式结果为true,那么执行if后面{}中代码

if 初始化语句; 条件表达式{
    语句块;
}

package main
import "fmt"
func main() {
    // 如果后续需要用到age变量, 可以将变量放到if外面
    age := 18
    if age >= 18{
        fmt.Println("成年人")
    }
}

package main
import "fmt"
func main() {
    // 如果后续不需要用到age变量, 可以将变量放到条件表达式前面
    if age := 18; age >= 18{
        fmt.Println("成年人")
    }
}

• 第二种格式:
  • 条件表达式结果为true,那么执行if后面{}中代码
  • 否则执行else后面{}中代码

if 初始化语句; 条件表达式{
    语句块;
}else{
    语句块;
}

package main
import "fmt"
func main() {
    if age := 18;age >= 18 {
        fmt.Println("成年人")
    }else{
        fmt.Println("未成年人")
    }
}

• 第三种格式:
  • if后面条件表达式结果为true,那么执行if后面{}中代码
  • 否则判断else if条件表达式是否为true,为true执行else if后面{}中代码
  • 否则依次判断后续else if条件表达式是否为true,哪个为true就执行哪个else if后面{}中代码
  • 都不满足则执行else后面{}中代码

if 初始化语句; 条件表达式{
    语句块;
}else if 条件表达式{
    语句块;
}
... ...
else{
    语句块;
}

package main
import "fmt"
func main() {
    if age := 18;age > 55{
        fmt.Println("老年人")
    }else if age >= 40{
        fmt.Println("中年人")
    }else if age >= 18{
        fmt.Println("成年人")
    }else{
        fmt.Println("未成年人")
    }
}

• 值得一提的是Go语言中没有C语言中的三目运算符, 所以C语言中三目能干的在Go语言中都只能通过if else的形式来完成

---

选择结构switch

• 和C语言不同的的是
  • 和if一样,表达式前面可以添加初始化语句
  • 和if一样,不需要编写圆括号
  • 和if一样,左大括号必须和表达式在同一行
  • case表达式的值不一定要是常量, 甚至可以不用传递
  • 一个case后面可以有多个表达式, 满足其中一个就算匹配
  • case后面不需要添加break
  • 可以在case语句块最后添加fallthrough,实现case穿透
  • case后面定义变量不需要添加{}明确范围
• 格式

switch 初始化语句; 表达式{
  case 表达式1, 表达式2:
        语句块;
  case 表达式1, 表达式2:
        语句块;
  default:
        语句块;
}

package main
import "fmt"
func main() {
    switch num := 3;num {
        case 1:
            fmt.Println("星期一")
        case 2:
            fmt.Println("星期二")
        case 3:
            fmt.Println("星期三")
        case 4:
            fmt.Println("星期四")
        case 5:
            fmt.Println("星期五")
        case 6:
            fmt.Println("星期六")
        case 7:
            fmt.Println("星期日")
        default:
            fmt.Println("Other...")
    }
}

package main
import "fmt"
func main() {
    switch num := 3;num {
    case 1,2,3,4,5:
        fmt.Println("工作日")
    case 6,7:
        fmt.Println("非工作日")
    default:
        fmt.Println("Other...")
    }
}

• 注意点:
  • case后面不用编写break, 不会出现case穿透问题
  • 如果想让case穿透,必须在case语句块最后添加fallthrough关键

package main
import "fmt"
func main() {
    switch num := 3;num {
    case 1:
        fallthrough
    case 2:
        fallthrough
    case 3:
        fallthrough
    case 4:
        fallthrough
    case 5:
        fmt.Println("工作日")
    case 6:
        fallthrough
    case 7:
        fmt.Println("非工作日")
    default:
        fmt.Println("Other...")
    }
}

• case后面不仅仅可以放常量,还可以放变量和表达式

package main
import "fmt"
func main() {
    value := 2
    switch num:=1; num {
    case value: // 变量
        fmt.Println("num等于value")
    default:
        fmt.Println("num不等于value")
    }
}

package main
import "fmt"
func main() {
    value := 2
    switch num:=1; num {
    case getValue(): // 函数
        fmt.Println("num等于value")
    default:
        fmt.Println("num不等于value")
    }
}
func getValue() int {
    return 1
}

package main
import "fmt"
func main() {
    switch num:=18; {
        case num >=0 && num <=10: // 表达式
            fmt.Println("num是一个0~10之间的数")
        case num >10 && num <=20:
            fmt.Println("num是一个11~20之间的数")
        default:
            fmt.Println("num是一个大于20的数")
    }
}

• case后面定义变量不用添加{}明确作用于范围

package main
import "fmt"
func main() {
    switch num := 1;num {
      case 1:
        value := 10 // 不会报错
        fmt.Println(value)
      default:
        fmt.Println("Other...")
    }
}

• 其它特性和C语言一样

---

循环结构for

• 和C语言不同的的是
  • 和if一样,条件表达式的值必须是布尔类型
  • 和if一样,不需要编写圆括号
  • 和if一样,左大括号必须和表达式在同一行
• 格式:

for 初始化表达式；循环条件表达式；循环后的操作表达式 {
    循环体语句;
}

package main
import "fmt"
func main() {
    for i:=0; i<10; i++{
        fmt.Println(i)
    }
}

• Go语言中没有while/dowhile循环, 所以可以通过如下格式实现C语言中while循环用法

package main
import "fmt"
func main() {
    i:=0
    for i<10 {
        fmt.Println(i)
        i++
    }
}

• 最简单死循环

package main
import "fmt"
func main() {
    for{
        fmt.Println("根本停不下来")
    }
}

• 除了实现基本的循环结构以外,Go语言还实现了一种高级for循环for...range循环
  • for...range循环可以快速完成对字符串、数组、slice、map、channel遍历
• 格式

for 索引, 值 := range 被遍历数据{
}

package main
import "fmt"
func main() {
    // 1.定义一个数组
    arr := [3]int{1, 3, 5}
    // 2.快速遍历数组
    // i用于保存当前遍历到数组的索引
    // v用于保存当前遍历到数组的值
    for i, v := range arr{
        fmt.Println(i, v)
    }
}

---

四大跳转

• 和C语言一样,Go语言中也有四大跳转语句, 分别是return、break、continue、goto
• break语句
  • Go语言中的break语句可以用于,立即跳出switch、for和select
  • 但不同的是Go语言中的break语句可以指定标签

package main
import "fmt"
func main() {
    for i:=0; i<10; i++{
        if(i == 5){
            break // 跳出所在循环
        }
        fmt.Println(i)
    }
}

• 利用break跳转到指定标签
  • 标签必须在使用之前定义
  • 标签后面只能跟switch和循环语句, 不能插入其它语句
  • 跳转到标签之后switch和循环不会再次被执行

package main
import "fmt"
func main() {
outer:
    switch num:=2; num {
    case 1:
        fmt.Println(1)
    case 2:
        fmt.Println(2)
        break outer
    default:
        fmt.Println("other")
    }
    fmt.Println("come here")
}

package main
import "fmt"
func main() {
outer:
    for i:=0; i<5; i++{
        for j:=0; j<10; j++ {
            if (j == 5) {
                break outer// 跳出到指定标签
            }
            fmt.Println(j)
        }
    }
    fmt.Println("come here")
}

• continue语句
  • Go语言中的continue语句可以用于,立即进入下一次循环
  • 但不同的是Go语言中的continue语句可以指定标签

package main
import "fmt"
func main() {
    for i:=0; i<5; i++{
        if (i == 2) {
            continue
        }
        fmt.Println(i)
    }
}

• 利用continue 跳转到指定标签
  • 标签必须在使用之前定义
  • 标签后面只能跟循环语句, 不能插入其它语句
  • 对于单层循环和直接编写continue一样
  • 对于多层循环,相当于跳到最外层循环继续判断条件执行

package main
import "fmt"
func main() {
outer:
    for i:=0; i<5; i++{
        fmt.Println("i =", i) // 0 1 2 3 4
        for j:=0; j<10; j++ {
            if (j == 5) {
                continue outer// 跳出到指定标签
            }
        }
    }
    fmt.Println("come here")
}

• goto语句
  • Go语言中的goto和C语言中用法一样, 用于在同一个函数中瞎跳

package main
import "fmt"
func main() {
    num := 1
outer:
    if(num <= 10){
        fmt.Println(num)
        num++
        goto outer // 死循环
    }
    fmt.Println("come here")
}

package main
import "fmt"
func main() {
    num := 1
    if(num <= 10){
        fmt.Println(num)
        num++
        goto outer // 死循环
    }
outer:
    fmt.Println("come here")
}

• Go语言中的return语句和C语言一模一样,都是用于结束函数,将结果返回给调用者