美文网首页golang
09-Go语言流程控制-指趣学院

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

作者: 极客江南 | 来源:发表于2018-09-17 14:48 被阅读224次

    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语言一模一样,都是用于结束函数,将结果返回给调用者

    相关文章

      网友评论

        本文标题：09-Go语言流程控制-指趣学院

        本文链接：https://www.haomeiwen.com/subject/mwvcmftx.html

        延伸阅读

        深度阅读

        • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

        栏目导航

        热点阅读

        golang

        关于我们|服务条款|联系我们|09-Go语言流程控制-指趣学院|投稿指南|网站地图|RSS订阅|排版工具|手机版

        提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

        Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

        备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

        本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

        所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！