GO语言小锤硬磕八.流程控制

go语言的流程控制：顺序结构、选择结构（if、switch）、循环结构（for）

1.选择结构if

        条件表达式的值必须是布尔值（go语言没有非零即真的概念）

        条件表达式前可以添加初始化语句

        不需要编写圆括号

        左大括号必须和条件语句在同一行

        与其他语言的if对比

        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语言没有三目运算符，只能通过if else 实现

2.选择结构switch

        表达式前年可以添加初始化语句

        不需要编写圆括号

        左侧大括号必须和表达式在同一行

        case表达式的值不一定要是常量，甚至可以不用传递

        一个case后面可以有多个表达式，满足其中一个就算匹配

        case后面不需要添加break

        可以再case语句块后面添加fallthrough，实现case穿透

        case后面定义变量不需要添加{}明确范围

         switch 初始化语句；表达式{

                case 表达式1，表达式2：

                        语句块

                case 表达式1，表达式2：

                        语句块

                default：

                        语句块        

        }

package main
import "fmt"
func main(){
//例子1
    switch num :=3;num{              //可以定义初值
        case 1:
            fmt.Println("星期一")    //不需要担心穿透
        case 2:
            fmt.Println("星期二")
        default:
            fmt.Println("Other..")
    }

//例子2
    switch num :=3;num{
        case 1,2,3,4,5:             //可以跟多条件
            fmt.Println("工作日")
        case 6,7:
            fmt.println("休息日")
        default:
            fmt.Println("Other..")

    }
//例子3

    switch num :=3;num{
        case 1:
            fallthrough                //x如果需要穿透可以使用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")
            
    }


//例子4   可以传入变量、函数和表达式
    value :=2                  //定义变量
    switch num:=3;num{
        case value:            //传入变量
            fmt.Println("相等2")

        case getValue():       //传入函数
            fmt.Println("相等3")

        case num>=0&&num<=10:  //传入表达式
            fmt.Println("在区间内")
        default:
            fmt.Println("不等")
    }

    func getValue() int{
        return 1
    }

//例子5  case后边定义不用添加{}明确作用范围
    switch num:= 1;num{
        case 1:
            value :=10      //不会报错
            fmt.Println(value)
        default：
            fmt.Println("Other")
    }
    
}

3.循环结构for

        条件表达式的值必须是布尔类型

        不需要编写圆括号

        左大括号必须和表达式在同一行

for 初始化表达式；循环条件表达式；循环后的操作表达式{

}

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

//例2    go语言中没有while/dowhile循环，可以用for代替
    i:=0
    for i<10{
        fmt.Println(i)
        i++   
    }    

//例3 最简单的死循环
    for{
        fmt.Println("停不下来")
    }
}

        高级的for循环结构   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)
    }
}

4.跳转

        四大跳转分别是 return、break、continue、goto

  1）break 立即跳出switch 、for、select

                go语言中break可指定标签

                        标签必须在使用之前定义

                        标签后只能跟switch和循环语句，不能插入其他语句

                        跳转标签后switch和循环不会再次被执行

package main
import "fmt"
func main(){
//例1 正常跳出
    for i:=0;i<10;i++{
        if(i==5){
            break //跳出循环
        }
        fmt.Println(i)
    }
//例2 跳出到标签
outer1:
    switch num:=2;num{
        case 1:
            fmt.Println(1)
        case 2:
            fmt.Println(2)
            break outer1          //跳转到标签
        default:
            fmt.Println("other")
    }
    fmt.Println("come here")


//例子3
outer2
    for i:=0;i<5;i++{
        for j:=0;j>10;j++{
            if(j==5){
                break outer //跳出到指定标签
            }
            fmt.Println(j)
        }        
    }
    fmt.Println("come here")
    
}

  2)continue 语句   立即进入下一次循环，可以指定标签

        标签必须提前定义

        标签后只能跟循环语句，不能插入其他语句

        对于单层循环和直接编写continue一样

        对于多层循环，相当于跳到最外层循环继续判断条件执行

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



outer:
    for i:=0;i<5;i++{
        fmt.Println("i=",1)
        for j:=0;j<10;j++{
            if(j==5){
                continue outer //跳出到指定标签
            }
        }
    }
}

3）goto语句  可以自由跳跃到指定的标签

package main
import "fmt"
func main(){
    num:=1
outer1: 
    if(num<=10){
        fmt.Println(num)
        num++
        if(num==5){
            goto outer2 //跳到标签2
        }
        goto outer1  //返回标签1
 
    }

outer2:
    fmt.Println("over")

}

4） return语句用于结束函数，结果返回给调用者