go之流程控制

一、与用户交互

var name string
fmt.Scanln(&name)   # 一定得传指针，因为我要修改的是name的值
fmt.Println(name)

二、if判断

1、if

if 条件 {
    代码1
    ...
}
 
例如：如果：女人的年龄>30，那么：叫阿姨。
var ageOfGirl int = 31
if ageOfGirl > 30 {
    fmt.Println("阿姨好")
}

2、if—else

if 条件 {
    代码1
    ...
}else{
    代码a
    ...
}
 
例如：如果：女人的年龄>30，那么：叫阿姨，否则：叫小姐
var ageOfGirl int = 18
if ageOfGirl > 30 {
    fmt.Println("阿姨好")
}else{
    fmt.Println("小姐好")
}

3、if—else if—else

if 条件1 {
    代码
    ...
}else if 条件2{
    代码
    ...
}else if 条件3{
    代码
    ...
}else{
    代码
    ...
}
 
例如：
如果：成绩》=90，那么：优秀，
如果：成绩》=80且<90，那么：良好，
如果：成绩》=70且<80，那么：普通
其它情况：很差
 
var score int = 50
if score >= 90 {
    fmt.Println("优秀")
}else if score >= 80 {
    fmt.Println("良好")
}else if score >= 70 {
    fmt.Println("普通")
}else {
    fmt.Println("很差")
}

4、if嵌套

if 条件1 {
    代码...
    if 条件x {
        代码
    }else{
        代码
    }
}else{
    代码
}
 
例如：
var ageOfGirl int = 18
var isSuccess bool = True     # 是否表白成功
if ageOfGirl > 30 {
    fmt.Println("阿姨好")
}else{
    fmt.Println("表白...")
    if isSuccess {
        fmt.Println("在一起...")
    }else{
        fmt.Println("强行在一起...")
    }
}

5、判断条件之前加可执行语句，用分号隔开

if age_of_girl := 18；age_of_girl > 30 {
    # 强调：如果是定义变量，这里只能用短声明 :=
    # 且这里定义的变量只能在当前if相关的代码体中使用
    fmt.Println("阿姨好")
}else{
    fmt.Println("小姐好")
}

三、switch分支选择

1、switch分支选择是什么？

switch英语里是岔道的意思，表明你面临了选择，在go语言里，当满足了岔道（分支）的条件，就会去执行岔道（分支）里的代码。这个if判断很类似，满足这个条件我就执行这块代码，满足另一个条件我就执行另一块代码。

2、为什么要有switch分支选择？

既然switch分支选择功能上和if判断类似，那为什么还要有它啊？存在即合理。虽然switch分支选择也可以用if判断来实现，但是在特定的情况下，switch分支选择要比if判断更简洁。

3、为什么要有switch分支选择？

①方式一

注意：

因为switch的判断就相当于“判断量==被判断量”，所以两者类型要相同，准确的讲是要能够写成“判断量==被判断量”的形式

拓展：

我们平时开发中尽量不要去使用break和fallthrough，break和fallthrough是用来解决历史遗留问题的，现在很多公司都在拿go去重写c++的程序，在c++里，switch的一个case运行结束后，会直接去运行下一个case的体代码，除非手动在case的末尾加上break。为了兼容c++里的break功能和一个case运行完直接运行下一个case的体代码这种情况，go语言里才加入了break和fallthrough的功能

举例：

var isUgly bool = true      # 客户是否长得丑
 
switch name := "女总经理"; name {
case "男总经理","女总经理":
    fmt.Println("总经理好")
case "预约访客"：
    if isUgly {
        break              # 长得丑就直接终止程序
    }else{
        fmt.Println("你微信号多少")
    }
    fmt.Println("你好")
default：
    fmt.Println("出门右转")
}

②方式二

举例：

var studentFather string = "校长"
 
switch score := 82; {
case score>=90,studentFather == "校长" :
    fmt.Println("优秀")
case score>=80 :
    fmt.Println("良好")
case score>=70 :
    fmt.Println("一般")
default :
    fmt.Println("很差")
 
}

四、for循环

1、基本形式：

for 初始语句；循环条件；追加语句{
    循环体代码...
}

详解：

for循环开始时会首先执行一次“初始条件”，然后接着判断“循环条件”是否为true，如果是true，那就开始执行“循环体代码”，每一次循环结束都会执行一次“追加语句”，然后继续判断“循环条件”，fasle就结束循环。

正常情况下，我们会在“初始条件”里写一个变量声明，通过对这个变量的判断，以及赋值来控制循环的次数。如：

for i := 0; i < 3; i++ {
    fmt.Println(i)
}

每次循环后变量i都会加1，直到不满足i<3这个循环条件，如此，循环就被限制成了3次。

省略形式：

初始语句，循环条件和追加条件都可以被省略，但“；”要保留，如下：

①省略初始语句

这没什么好说的，初始语句就是在for循环第一次执行的时候有且只只会执行一次。省略了它，写在for循环外面也一样。但需要注意的是，如果变量在初始化语句中定义，那么它就只能在for中被使用。

var i int = 0
for ; i < 3; i++{
    ...
} 

②省略追加语句

这也没什么好说的，追加语句就是在每次循环结束的时候会执行的语句。省略了它，就写在for循环的循环体代码内，效果也一样。它的省略是为了让循环更加灵活，我们可以把“i++”写在循环体的任意一行，也可以通过判断对它进行逻辑修饰。

var isAdd2 = true
 
for i := 0; i < 3; {
    if isAdd2{
        i += 2
    }else{
        i++
    }
}

同时省略初始语句和追加语句时，“；”可以不写，如：

var i int = 0
var isAdd2 = true
 
for i < 3 {
    if isAdd2{
        i += 2
    }else{
        i++
    }
}

③省略循环条件

当循环条件被省略的时候，for循环运行一次之后进行循环条件判断的时候，会把循环条件当成true。换句话说，就是会一直循环。如：

for i:=0; ; i++{
    fmt.Println(i)
}
 
# 相当于：
for i:=0; true; i++{
    fmt.Println(i)
}

for后面的语句都省略的时候，“；”也可以不写：

for {
    i++
    fmt.Println(i)
}

2、for循环的嵌套

for循环里嵌套了一个或者多个for循环，如下：
 
for i:=0; i<3; i++ {
    fmt.Println("第一层：",i)
    for j:=0; j<3; j++ {
        fmt.Println("第二层：",j)
    }
}

3、for循环的终止

①变量开关

for tag:=true; tag;{
    .....
    for tag {
        ....
        tag = false
    }
}

我们把变量开关放在循环条件里，通过对变量开关的控制（赋值为fasle），来跳出循环。

②continue

for i:=0; i<10; i++{
    if i == 5 {
        continue
    }
    fmt.Println(i)
}

当前循环一旦碰到continue，不管循环体里剩下多少代码没有执行，都会直接跳过，开始下一次循环

③break

for i:=0; i<3; i++{
    fmt.Println("第一层：",i)
    for j:=0; j<10; j++{
        fmt.Println("第二层：",j)
        if j==1 {
            break
        }
    }
}
 
结果为
第一层： 0
第二层： 0
第二层： 1
第一层： 1
第二层： 0
第二层： 1
 
说明：
如果没有break，那么第二层循环应该执行10次，但我在j=1（第二层循环执行到第二次）的时候加上了break，那么就直接跳出了第二层循环，剩下的8次都不会再执行

五、标签

1、什么是标签

标签是用来给代码做标记的，记录住代码的在程序中的位置。

2、为什么要有标签

快速的找到被标记的代码，方便进行相应的操作。

3、怎么用标签

标签的格式：

标签名1：
    for i := 0; i < 5; i++ {
        代码...
    }
标签名2：
    switch {
        代码...
    }
标签名3：
    fmt.Println("今天天气不错")

说明：

①为了区分标签和变量，通常标签名我们会用大写字母加数字来表示。

②创建了标签就一定要使用，不然会引发错误。

4、break+标签

我们在for循环里讲到过break，for循环里单独写break是用来跳出本层循环的。如：

for {
    for i:=0; ; i++ {
        if i == 2 {
            fmt.Println(i)
            break
        }
    }
}

运行的结果是控制台无限打印2，原因是这里的break只是跳出了里层循环，而最外层的循环并没有被终止。

那现在我就想满足条件时，终止所有循环，怎么办？我们改变它的循环条件不就完了嘛，之前是不是学过一个变量开关的方法啊？如下：

for tag:=true; tag; {
    for i:=0; tag; i++ {
        if i==2 {
            fmt.Println(i)
            tag = false
        }
    }
}

还有其它方法吗？当然有，就是我们下面要说的break + 标签。如下：

LABEL1:
    for {
        for i:=0; ; i++ {
            if i == 2 {
                fmt.Println(i)
                break LABEL1
            }
        }
    }

我们用LABEL1来标记最外层循环，然后用break LABEL1来指定要跳出的循环，这里跳出的是最外层循环。当然也可以用标签去标记内层循环，如：

for {
    LABEL1:
        for {
            for i:=0; ; i++ {
                if i == 2 {
                    fmt.Println(i)
                    break LABEL1
                }
            }
        }
}

5、continue+标签

continue + 标签，用于终止指定循环的本次循环并继续下一次循环。用法和break一样，只是关键字不同。如：

LABEL1:
    for i:=0; i<3; i++ {
        for j:=0; j<3; j++ {
            continue LABEL1
            fmt.Println("我是内层循环，j=",j)
        }
        fmt.Println("我是外层，i=",i)
    }

6、goto+标签

代码都是从上而下一行行执行的，而goto + 标签，可以强行跳转到函数体内指定代码，并继续向下执行。

在一般的开发中，“goto LABEL”能不用就不用，除非是遇到的问题再也没有其它更好的办法可以解决。因为“goto LABEL”牺牲的是代码可读性和可维护性。

func main(){
    for i:=0; i<3; i++ {
        fmt.Println(i)
        if i>1 {
            goto EXIT
        }
    }
EXIT:
    fmt.Println("exit")
}

注意：

①goto语句仅适用于函数内部跳转，不可跳转到其它函数。

func text1() {
LABEL1:            # 报错 label LABEL1 defined and not used
    fmt.Println("我是text1")
}
 
func main() {
    goto LABEL1   # 报错 label LABEL1 not defined
}

这和函数作用域有关，我们在函数这一章中会具体讲解

②goto语句不能跳过变量声明语句。

goto LABEL1
    # 报错 goto LABEL1 jumps over declaration of a
    # goto LABEL1 跳过了a的声明
    var a int= 111
LABEL1:
    fmt.Println("测试......")