Go基础 - Go基础——流程控制 - 《够浪》

分支控制
循环控制
标签和跳转

分支控制

if后面的条件判断子句不需要用小括号括起来。
if后面可以带一个简单的初始化语句，并以分号分割，该简单语句声明的变量的作用域是整if语句块，包括后面的else if和 else分支。

注意：go不支持三元操作符(三目运算符)

 "a > b ? a : b"。

单分支控制

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

eg:

package main
import "fmt"
func main() {
    num := -1
    if num < 0 {
        num = -num
    }
    fmt.Println(num)
}

双分支控制

if 布尔表达式{
}else{
}

eg:

package main
import "fmt"
func main() {
    score := 59
    if score >= 60 {
        fmt.Println("pass")
    } else {
        fmt.Println("not pass")
    }
}

多分支控制

if 条件表达式1{
}else if条件表达式2 {
}else{
}

eg:

package main
import "fmt"
func judgeScore(score int) string {
    var result string
    if score >= 90 {
        result = "优"
    } else if score >= 80 {
        result = "良"
    } else if score >= 70 {
        result = "中"
    } else if score >= 60 {
        result = "及格"
    } else {
        result = "继续努力"
    }
    return result
}
func main() {
    fmt.Println(judgeScore(75))
    fmt.Println(judgeScore(40))
    fmt.Println(judgeScore(95))
    fmt.Println(judgeScore(63))
    fmt.Println(judgeScore(86))
}

执行结果

中
继续努力
优
及格
良

switch

Go的switch非常灵活，表达式不必是常量或整数，执行的过程从上至下，直到找到匹配项；
而如果switch没有表达式，它会匹配true。
Go里面switch默认相当于每个case最后带有break，
匹配成功后不会自动向下执行其他case，而是跳出整个switch,
省略条件表达式，可当 if…else if…else

package main
import "fmt"
func GetGrade(sore int) (grade string) {
    switch {
    case sore > 80:
        grade = "A"
    case sore > 60:
        grade = "B"
    default:
        grade = "C"
    }
    return
}
func main() {
    fmt.Printf("你的等级是 %s\n", GetGrade(90))
    fmt.Printf("你的等级是 %s\n", GetGrade(78))
    fmt.Printf("你的等级是 %s\n", GetGrade(35))
}

执行结果

你的等级是 A
你的等级是 B
你的等级是 C

用fallthrough强制执行后面的case代码

package main
import "fmt"
func main() {
    var k = 0
    switch k {
    case 0:
        println("fallthrough")
        fallthrough
    case 1:
        fmt.Println("1")
    case 2:
        fmt.Println("2")
    default:
        fmt.Println("def")
    }
}

执行结果,使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。注意fallthrough 只能穿透下一层。

0
1

同时可以将多个case 合并在一起

package main
import "fmt"
func main() {
    var m = 0
    switch m {
    case 0, 1:
        fmt.Println("1")
    case 2:
        fmt.Println("2")
    default:
        fmt.Println("def")
    }
}

循环控制

Go 语言仅支持一种循环语句，即 for语句，go 语言没有while和do while

for 循环初始化;循环条件;循环变量迭代{
}

类似的 while 循环语句

for 循环判断条件{
}

类似 while (1)死循环语句

for {
}

标签和跳转

Go语言使用标签（Lable）来标识一个语句的位置，用于 goto 、break、 continue 语句的跳转，标签的语法是：
goto语句本身就是做跳转用的，而break和continue是配合for使用的。所以goto的使用不限于for，
通常与条件语句配合使用在for循环中break和continue可以配合标签使用。

goto

语句用于函数的内部的跳转，需要配合标签一起使用，
goto语句可以无条件地转移到过程中指定的行。
通常与条件语句配合使用。可用来实现条件转移，构成循环，跳出循环体等功能。
在结构化程序设计中一般不主张使用goto语句，以免造成程序流程的混乱
goto对应(标签)既可以定义在for循环前面,也可以定义在for循环后面，当跳转到标签地方时，继续执行标签下面的代码。

package main
import "fmt"
func main() {
    var a =0
    for ;a<5;a++{
        if a>3{
            goto Loop
        }
        fmt.Printf("for ...%d\n",a)
    }
Loop:           //放在for后边
    fmt.Printf("loop ...%d\n",a)
}

打印结果

for...0
for...1
for...2
for...3
loop...4

放在前面一直死循环

package main
import "fmt"
func main() {
    var a =0
Loop:           //放在for前面 一直死循环
    fmt.Printf("loop ...%d\n",a)
    for ;a<5;a++{
        if a>3{
            goto Loop
        }
        fmt.Printf("for ...%d\n",a)
    }
}

注意的是goto语句与标签之间不能有变量声明，否则编译错误。

func foo(){
    goto flag
    var s = "hello world"
    fmt.Println(s)
flag:
    s = "hello golang"
    fmt.Println(s)
}

# command-line-arguments
./goto.go:20:7: goto flag jumps over declaration of s at ./goto.go:21:6

break

break标签能用于循环，跳出后不再执行标签对应的循环体

package main
import "fmt"
func main() {
    for i := 0; i <= 2; i++ {
        for j := 1; j <= 3; j++ {
            if j == 2 {
                break
            }
            fmt.Printf("%d+%d=%d\n", i, j, i+j)
        }
    }
}

执行结果

0+1=1
1+1=2
2+1=3

break只是跳出了第一层for循环,使用标签后跳出到指定的标签,break只能跳出到之前，如果将Loop标签放在后边则会报错

package main
import "fmt"
func main() {
    var a =0
    for ;a<5;a++{
        if a>3{
            goto Loop
        }
        fmt.Printf("for ...%d\n",a)
    }
Loop:           //放在for后边
    fmt.Printf("loop ...%d\n",a)
}

打印结果

0+1=1

continue

package main
import (
    "fmt"
)
func main() {
    FirstNames := []string{"张", "李", "王"}
    LastNames := []string{"三", "四", "五"}
    for i, firstName := range FirstNames {
        for j, lastName := range LastNames {
            if i == 1 && j==1 {
                continue
            }
            fmt.Printf("%d-%d:%s%s\n",i,j, firstName, lastName)
        }
    }
}

打印结果

0-0:张三
0-1:张四
0-2:张五
1-0:李三
1-2:李五
2-0:王三
2-1:王四
2-2:王五

package main
import (
    "fmt"
)
func main() {
    FirstNames := []string{"张", "李", "王"}
    LastNames := []string{"三", "四", "五"}
    Loop:
    for i, firstName := range FirstNames {
        for j, lastName := range LastNames {
            if i == 1 && j==1 {
                continue Loop
            }
            fmt.Printf("%d-%d:%s%s\n",i,j, firstName, lastName)
        }
    }
}

0-0:张三
0-1:张四
0-2:张五
1-0:李三
2-0:王三
2-1:王四
2-2:王五