Go从入门到放弃之流程控制

简介: Go从入门到放弃之流程控制

阅读目录

回到顶部

概述

流程控制主要用于设定计算执行的次序,建立程序的逻辑结构。Go 语言的流程控制和其他编程语言类似,支持如下几种流程控制语句:

  • 条件语句:用于条件判断,对应的关键字有 ifelseelse if
  • 分支语句:用于分支选择,对应的关键字有 switchcaseselect(用于通道,后面介绍协程时会提到);
  • 循环语句:用于循环迭代,对应的关键字有 forrange
  • 跳转语句:用于代码跳转,对应的关键字有 goto

回到顶部

一、条件语句

条件语句的示例模板如下:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

// if

if condition {

    // do something

}

 

// if...else...

if condition {

    // do something

else {

    // do something

}

 

// if...else if...else...

if condition1 {

    // do something

else if condition2 {

    // do something else

else {

    // catch-all or default

}

一个简单的条件语句示例代码如下:

1

2

3

4

5

6

7

8

9

10

11

12

score := 100

if score > 90 {

    fmt.Println("Grade: A")

else if score > 80 {

    fmt.Println("Grade: B")

else if score > 70 {

    fmt.Println("Grade: C")

else if score > 60 {

    fmt.Println("Grade: D")

else {

    fmt.Println("Grade: F")

}

注意事项

关于 Go 语言的条件语句,需要注意以下几点:

  • 条件语句不需要使用圆括号将条件包含起来 ()
  • 无论语句体内有几条语句,花括号 {} 都是必须存在的;
  • 左花括号 { 必须与 if 或者 else 处于同一行;
  • if 之后,条件语句之前,可以添加变量初始化语句,使用 ; 间隔,比如上述代码可以这么写 if score := 100; score > 90 {

回到顶部

二、分支语句

分支语句会根据传入条件的不同,选择不同的分支代码执行。

Go 语言的分支语句和其他编程语言类似,只是不需要在每个分支结构中显式通过 break 语句退出:

1

2

3

4

5

6

7

8

switch var1 {

    case val1:

        ...

    case val2:

        ...

    default:

        ...

}

通过分支语句改写if语句的示例代码:  

1

2

3

4

5

6

7

8

9

10

11

12

13

score := 100

switch {

case score >= 90:

    fmt.Println("Grade: A")

case score >= 80 && score < 90:

    fmt.Println("Grade: B")

case score >= 70 && score < 80:

    fmt.Println("Grade: C")

case score >= 60 && score < 70:

    fmt.Println("Grade: D")

default:

    fmt.Println("Grade: F")

}

注意这个时候,不能把变量 score 放到 switch 关键字后面,否则会报错,只有在与 case 分支值判等的时候,才可以这么做:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

score := 100

switch score {

case 90, 100:

    fmt.Println("Grade: A")

case 80:

    fmt.Println("Grade: B")

case 70:

    fmt.Println("Grade: C")

case 60:

case 65:

    fmt.Println("Grade: D")

default:

    fmt.Println("Grade: F")

}

合并分支

在 Go 语言中,我们可以用逗号分隔不同的分支条件来达到合并分支语句的目的,如 case 90,100,而不能像其它语言那样,通过多个相邻的 case 语句来合并相同的分支语句

1

2

3

4

5

6

7

8

9

10

func testSwitch() {

    switch n := 7; n {

    case 1, 3, 5, 7, 9:

        fmt.Println("奇数")

    case 2, 4, 6, 8:

        fmt.Println("偶数")

    default:

        fmt.Println(n)

    }

}

分支还可以使用表达式,这时候switch语句后面不需要再跟判断变量

1

2

3

4

5

6

7

8

9

10

11

12

13

func switchDemo4() {

    age := 30

    switch {

    case age < 25:

        fmt.Println("好好学习吧")

    case age > 25 && age < 35:

        fmt.Println("好好工作吧")

    case age > 60:

        fmt.Println("好好享受吧")

    default:

        fmt.Println("活着真好")

    }

}

fallthrough

fallthrough语法可以执行满足条件的case的下一个case,是为了兼容C语言中的case设计的。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

func switchDemo5() {

    s := "a"

    switch {

    case s == "a":

        fmt.Println("a")

        fallthrough

    case s == "b":

        fmt.Println("b")

    case s == "c":

        fmt.Println("c")

    default:

        fmt.Println("...")

    }

}<br><br>输出:<br><code class=" language-bash">  a<br></code><code class=" language-bash">  b</code>

注意事项

在 Go 语言中使用 switch...case... 分支语句时,需要注意以下几点:

  • 和条件语句一样,左花括号 { 必须与 switch 处于同一行;
  • 单个 case 中,可以出现多个结果选项(通过逗号分隔);
  • 与其它语言不同,Go 语言不需要用 break 来明确退出一个 case
  • 只有在 case 中明确添加 fallthrough 关键字,才会继续执行紧跟的下一个 case
  • 可以不设定 switch 之后的条件表达式,在这种情况下,整个 switch 结构与多个 if...else... 的逻辑作用等同。

回到顶部

三、循环语句

for 循环

Go 语言中的循环语句只支持 for 关键字,而不支持 whiledo-while 结构。关键字 for 的基本使用方法与其他语言类似,只是循环条件不含括号,比如我们要计算 1 到 100 之间所有数字之和,可以这么做:

1

2

3

4

5

6

7

//for 初始语句;条件表达式;结束语句{

//    循环体语句

//}sum := 0

for i := 1; i <= 100; i++ {

    sum += i

}

fmt.Println(sum)

无限循环

Go 语言不支持 whiledo-while 循环语句,对于无限循环场景,可以通过不带循环条件的 for 语句实现,下面我们通过无限循环来改写上述计算 1 到 100 以内数字之和的实现如下:

 

1

2

3

4

5

6

7

8

9

10

11

12

//for {

//    循环体语句

//}// sum := 0

i := 0

for {

    i++

    if i > 100 {

        break

    }

    sum += i

}

fmt.Println(sum)

for-range 结构

Go 语言还支持通过 for-range 结构对其进行循环遍历,一下为示例

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

遍历切片

a := []int{1, 2, 3, 4, 5, 6}

for k, v := range a {

    fmt.Println(k, v)

}

 

 

忽略索引/键

for _, v := range a {

    fmt.Println(v)

}

 

忽略元素值

for k := range a {

    fmt.Println(k)

}

基于条件判断进行循环

基于条件判断进行循环,只有满足指定的条件才会执行循环体中的代码  

1

2

3

4

5

6

7

sum := 0

i := 0

for i < 100 {

    i++

    sum += i

}

fmt.Println(sum)

goto

goto语句通过标签进行代码间的无条件跳转。goto语句可以在快速跳出循环、避免重复退出上有一定的帮助。Go语言中使用goto语句能简化一些代码的实现过程。 例如双层嵌套的for循环要退出时:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

func gotoDemo1() {

    var breakFlag bool

    for i := 0; i < 10; i++ {

        for j := 0; j < 10; j++ {

            if j == 2 {

                // 设置退出标签

                breakFlag = true

                break

            }

            fmt.Printf("%v-%v\n", i, j)

        }

        // 外层for循环判断

        if breakFlag {

            break

        }

    }

}

使用goto语句能简化代码:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

func gotoDemo2() {

    for i := 0; i < 10; i++ {

        for j := 0; j < 10; j++ {

            if j == 2 {

                // 设置退出标签

                goto breakTag

            }

            fmt.Printf("%v-%v\n", i, j)

        }

    }

    return

    // 标签

breakTag:

    fmt.Println("结束for循环")

}

回到顶部

四、注意事项

在 Go 语言中使用循环语句时,需要注意以下几点:

  • 和条件语句、分支语句一样,左花括号 { 必须与 for 处于同一行;
  • 不支持 whiedo-while 结构的循环语句;
  • 可以通过 for-range 结构对可迭代集合进行遍历;
  • 支持基于条件判断进行循环迭代;
  • 允许在循环条件中定义和初始化变量,且支持多重赋值;
  • Go 语言的 for 循环同样支持 continuebreak 来控制循环,但是它提供了一个更高级的 break,可以选择中断哪一个循环,如下例:

1

2

3

4

5

6

7

8

9

JLoop:

for j := 0; j < 5; j++ {

    for i := 0; i < 10; i++ {

        if i > 5 {

            break JLoop

        }

        fmt.Println(i)

    }

}


相关文章
|
10天前
|
Go C语言
Go语言入门:分支结构
本文介绍了Go语言中的条件语句,包括`if...else`、`if...else if`和`switch`结构,并通过多个练习详细解释了它们的用法。`if...else`用于简单的条件判断;`if...else if`处理多条件分支;`switch`则适用于基于不同值的选择逻辑。特别地,文章还介绍了`fallthrough`关键字,用于优化重复代码。通过实例如判断年龄、奇偶数、公交乘车及成绩等级等,帮助读者更好地理解和应用这些结构。
34 14
|
3月前
|
存储 设计模式 安全
Go语言中的并发编程:从入门到精通###
本文深入探讨了Go语言中并发编程的核心概念与实践技巧,旨在帮助读者从理论到实战全面掌握Go的并发机制。不同于传统的技术文章摘要,本部分将通过一系列生动的案例和代码示例,直观展示Go语言如何优雅地处理并发任务,提升程序性能与响应速度。无论你是Go语言初学者还是有一定经验的开发者,都能在本文中找到实用的知识与灵感。 ###
|
3月前
|
Serverless Go
Go语言中的并发编程:从入门到精通
本文将深入探讨Go语言中并发编程的核心概念和实践,包括goroutine、channel以及sync包等。通过实例演示如何利用这些工具实现高效的并发处理,同时避免常见的陷阱和错误。
|
4月前
|
安全 Go 开发者
破译Go语言中的并发模式:从入门到精通
在这篇技术性文章中,我们将跳过常规的摘要模式,直接带你进入Go语言的并发世界。你将不会看到枯燥的介绍,而是一段代码的旅程,从Go的并发基础构建块(goroutine和channel)开始,到高级模式的实践应用,我们共同探索如何高效地使用Go来处理并发任务。准备好,让Go带你飞。
|
5月前
|
关系型数据库 Go 数据处理
高效数据迁移:使用Go语言优化ETL流程
在本文中,我们将探索Go语言在处理大规模数据迁移任务中的独特优势,以及如何通过Go语言的并发特性来优化数据提取、转换和加载(ETL)流程。不同于其他摘要,本文不仅展示了Go语言在ETL过程中的应用,还提供了实用的代码示例和性能对比分析。
|
4月前
|
存储 安全 Go
Go语言切片:从入门到精通的深度探索###
本文深入浅出地剖析了Go语言中切片(Slice)这一核心概念,从其定义、内部结构、基本操作到高级特性与最佳实践,为读者提供了一个全面而深入的理解。通过对比数组,揭示切片的灵活性与高效性,并探讨其在并发编程中的应用优势。本文旨在帮助开发者更好地掌握切片,提升Go语言编程技能。 ###
|
6月前
|
算法 测试技术 Go
|
6月前
|
Unix Go
Go从入门到放弃之时间操作
Go从入门到放弃之时间操作
|
6月前
|
机器学习/深度学习 移动开发 Linux
Go从入门到放弃之文件操作
Go从入门到放弃之文件操作
|
6月前
|
Java Go PHP
Go从入门到放弃之错误处理
Go从入门到放弃之错误处理