• Go学习第四章——程序流程控制

    Go学习第四章——程序流程控制

    1. 流程控制的作用：
      流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。

    2. 控制语句的分类：
      控制语句分为三类：顺序、选择和循环。
      “顺序结构”代表“先执行a，再执行b”的逻辑。
      “条件判断结构”代表“如果…，则…”的逻辑。
      “循环结构”代表“如果…，则再继续…”的逻辑。
      三种流程控制语句就能表示所有的事情！不信，你可以试试拆分你遇到的各种事情。这三种基本逻辑结构是相互支撑的，它们共同构成了算法的基本结构，无论怎样复杂的逻辑结构，都可以通过它们来表达。所以任何一种高级语言都具备上述两种结构。
      本章是大家真正进入编程界的“门票”。

    3. 流程控制的流程：

    在这里插入图片描述

    1 分支结构

    1.1 单分支

    基本语法

    if 条件表达式 {
  逻辑代码
}

    • 1
    • 2
    • 3

    当条件表达式为ture时，就会执行得的代码。
    PS：条件表达式左右的()可以不写，也建议不写
    PS：if和表达式中间，一定要有空格
    PS：在Golang中，{}是必须有的,就算你只写一行代码。

    案例讲解

    func main() {
    // 实现功能：如果口罩的库存小于30个，提示：库存不足：

    /*var count int = 100
    // 单分支：
    if count < 30 {
       fmt.Println("对不起，口罩存量不足")
    }*/

    //在golang里，if后面可以并列的加入变量的定义：
    if count := 20; count < 30 {
       fmt.Println("对不起，口罩存量不足")
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    输出：

    对不起，口罩存量不足

    • 1
    1.2 双分支

    基本语法

    if 条件表达式 {
   逻辑代码1
} else {
   逻辑代码2
}

    • 1
    • 2
    • 3
    • 4
    • 5

    当条件表达式成立，即执行逻辑代码1，否则执行逻辑代码2。{}也是必须有的。

    案例讲解

    func main() {
    var age byte
    fmt.Println("请问你的年龄多少？")
    fmt.Scanln(&age)
    if age < 18 {
       fmt.Println("你还没有成年！")
    } else {
       fmt.Println("你已经成年了！！")
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    输出：

    请问你的年龄多少？
18
你已经成年了！！

    • 1
    • 2
    • 3
    1.3 多分支

    基本语法

    if 条件表达式1 {
    逻辑代码1
} else if 条件表达式2 {
    逻辑代码2
}
.......
else {
                逻辑代码n
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    案例讲解

    略。。。。。只是多了几个else，略了。。

    1.4 switch分支

    基本语法

    switch 表达式 {
	case 值1,值2,.….:
		语句块1
	case 值3,值4,...:
		语句块2
	....
	default:
		语句块
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    ps：case后是一个表达式（即：常量值、变量、一个有返回值的函数都可以）

    ps：case后面可以有多个表达式

    ps：case后面的表达式如果是常量值，则不能重复

    补充：穿透-fallthrough，如果在case语句块后增加fallthrough，则会继续执行下一个case，也叫switch穿透

    案例讲解

    func main() {
	// a,b,c,d,e,f,g
	var week byte
	fmt.Println("请输入一个字符，在a,b,c,d,e,f,g里：")
	fmt.Scanf("%c", &week)
	switch week {
	case 'a':
		fmt.Println("星期一")
	case 'b':
		fmt.Println("星期二")
	case 'c':
		fmt.Println("星期三")
	case 'd':
		fmt.Println("星期四")
	case 'e':
		fmt.Println("星期五")
	case 'f', 'g':
		fmt.Println("周末休息日")
	default:
		fmt.Println("您的输入有误，请重新输入")
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    输出：

    请输入一个字符，在a,b,c,d,e,f,g里：
f
周末休息日

    • 1
    • 2
    • 3

    2 循环结构

    2.1 for循环

    for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化，即执行初始表达式；随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环；最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。

    语法结构：

    for 初始表达式; 布尔表达式; 迭代因子 {
	循环体;
}

    • 1
    • 2
    • 3
    1. 初始化部分设置循环变量的初值
    2. 条件判断部分为任意布尔表达式
    3. 迭代因子控制循环变量的增减

    简单使用：

    func main() {
    for a := 1; a <= 10; a++ {
       fmt.Println("打印", a, "次")
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5

    输出：

    打印 1 次
打印 2 次
打印 3 次
打印 4 次
打印 5 次
打印 6 次
打印 7 次
打印 8 次
打印 9 次
打印 10 次

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    注意事项：

    1. 循环条件是返回一个布尔值的表达式

    2. for循环的第二种使用方式

      for 循环判断条件 {
	// 循环执行语句
}

      • 1
      • 2
      • 3

    3. for循环的第三种使用方式

      for {
    // 循环执行语句
}

      • 1
      • 2
      • 3

      这种方式等价for ; ; {} 是一个无限循环，通常需要配合break语句使用。

    4. Golang提供for-range的方式，可以方便遍历字符串、数组、切片、字典等（注：数组的遍历，我们放到讲数组的时候再讲解），案例说明如何遍历字符串。

      func main() {
    // 字符串遍历方式1-传统方式
    var str string = "hello,world!"
    for i := 0; i < len(str); i++ {
       fmt.Printf("i的值为：%d ,str[i]的值为：%c \n", i, str[i])
    }

    fmt.Println()

    // 字符串遍历方式2-for-range
    str = "abc~ok!"
    for index, val := range str {
       fmt.Printf("index=%d, val=%c \n", index, val)
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15

      **注意：**在使用 for-range 遍历字符串时，返回的 val 类型为 rune 类型，而不是 byte 类型。因为字符串在 Go 语言中是采用 UTF-8 编码，每个 rune 类型表示一个 Unicode 码点，可以正确地表示任何 Unicode 字符。因此，在处理和打印中文字符时，一定要注意字符编码的正确性。

    2.2 while和dowhile的实现

    while的实现：

    for {
    if 循环条件表达式 {
       break // 跳出for循环..
    }
    循环操作（语句）
    循环变量迭代
}

// 例子
func main() {
	var i int = 1
	for {
		if i > 10 {
			break // 跳出for循环..
		}
		fmt.Println("hello world") // 循环操作（语句）
		i++                        // 循环变量迭代
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    do while的实现

    for {
    循环操作（语句）
    循环变量迭代
    if 循环条件表达式 {
       break // 跳出for循环..
    }
}

// 例子 
func main() {
	var i int = 1
	for {
		fmt.Println("hello world")
		i++
		if i > 0 { // 故意的
			break // 跳出for循环..
		}
	}
}
// 输出：hello world

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    2.3 经典案例——打印金字塔
    func main() {
    var n int
    fmt.Println("请输入你想要显示的金字塔层数：")
    fmt.Scanf("%d", &n)
    for i := 1; i <= n; i++ {
       // 打印空格
       for j := 1; j <= n-i; j++ {
          fmt.Print(" ")
       }

       // 打印星号
       for k := 1; k <= 2*i-1; k++ {
          fmt.Print("*")
       }

       fmt.Println() // 换行
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    输出：

    请输入你想要显示的金字塔层数：
5
    *    
   ***   
  *****  
 ******* 
*********

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    2.4 经典案例——打印九九乘法表
    func main() {
    for i := 1; i <= 9; i++ {
       for j := 1; j <= i; j++ {
          fmt.Printf("%d*%d=%-2d ", j, i, i*j)
       }
       fmt.Println()
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    输出：

    1*1=1
1*2=2  2*2=4
1*3=3  2*3=6  3*3=9
1*4=4  2*4=8  3*4=12 4*4=16
1*5=5  2*5=10 3*5=15 4*5=20 5*5=25
1*6=6  2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7  2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8  2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9  2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    3 跳转控制语句

    3.1 break

    break在循环中的作用：

    package main
import "fmt"
func main(){
        //功能：求1-100的和，当和第一次超过300的时候，停止程序
        var sum int = 0
        for i := 1 ; i <= 100 ; i++ {
                sum += i
                fmt.Println(sum)
                if sum >= 300 {
                        //停止正在执行的这个循环：
                        break 
                }
        }
        fmt.Println("-----ok")
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    总结：
    1.switch分支中，每个case分支后都用break结束当前分支，但是在go语言中break可以省略不写。
    2.break可以结束正在执行的循环
    深入理解：

    package main
import "fmt"
func main(){
        //双重循环：
        for i := 1; i <= 5; i++ {
                for j := 2; j <= 4; j++ {
                        fmt.Printf("i: %v, j: %v \n",i,j)
                        if i == 2 && j == 2 {
                                break
                        }
                }
        }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    总结：break的作用结束离它最近的循环
    结果：

    i: 1, j: 2
i: 1, j: 3
i: 1, j: 4
i: 2, j: 2
i: 3, j: 2
i: 3, j: 3
i: 3, j: 4
i: 4, j: 2
i: 4, j: 3
i: 4, j: 4
i: 5, j: 2
i: 5, j: 3
i: 5, j: 4

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    3.2 continue
    func main() {
	for i := 1; i <= 100; i++ {
		if i%6 != 0 {
			continue //结束本次循环，继续下一次循环
		}
		fmt.Println(i)
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    结论：continue的作用是结束离它近的那个循环当前循环，开始下一次循环

    3.3 goto
    1. Golang的 goto 语句可以无条件地转移到程序中指定的行。
    2. goto语句通常与条件语句配合使用。可用来实现条件转移.
    3. 在Go程序设计中一般不建议使用goto语句，以免造成程序流程的混乱。
    4. 代码展示：
    package main

import "fmt"

func main() {
	var (
		input string
		count int
	)

start:
	fmt.Println("请输入一个合法的字符串：")
	fmt.Scan(&input)
	if input == "" {
		goto start
	}

	for i := 0; i < len(input); i++ {
		if input[i] == 'a' || input[i] == 'A' {
			count++
		}
	}

	fmt.Printf("字符串 \"%s\" 中包含 %d 个字母 \"a\"。\n", input, count)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    以上代码实现了一个简单的统计字符串中字母 “a” 出现次数的程序。程序通过使用无限循环和 goto 语句，让用户输入一个字符串，如果输入的字符串为空，则返回 start 标签，继续要求用户输入。

    当用户输入一个非空字符串时，程序开始统计其中字母 “a” 的个数，结束后输出结果。在这个过程中，goto 语句用于实现 “输入不为空时跳转到计算代码块” 的功能。这种方式在少数情况下可能比较有用，但要谨慎使用。

    需要注意，过多的使用 goto 语句可能会导致程序阅读性和可维护性降低。因此，在实际编写代码时，应该尽可能避免使用 goto 语句，用更加结构化的语言特性来代替。

    3.4 return

    return 是 Go 语言中的一个关键字，用于结束当前函数或方法的执行，并返回结果（可选）。return 语句可以带有一个或多个返回值。同时，和其他语言不同的是，在 Go 语言中，return 语句可以被放在函数或方法中的任意位置。

    return 语句的使用场景包括但不限于：

    • 在函数或方法执行过程中，需要提前跳出函数或方法；
    • 在函数或方法返回结果之前，需要对某些资源进行清理或释放；
    • 函数或方法执行成功或失败后，需要返回相应结果给调用方；
    • 函数或方法需要直接返回某个值，而不需要继续执行下去。

    这里只讲解，提前跳出循环的案例：

    func main() {
    for i := 1; i <= 100; i++ {
       fmt.Println(i)
       if i == 4 {
          return //结束当前的函数
       }
    }
    fmt.Println("hello golang")
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    输出：

    1
2
3
4

    • 1
    • 2
    • 3
    • 4

    Over~~~

    第四章结束啦！！！下一步结构体，冲冲冲！！！

  • 相关阅读:
    RK3568 学习笔记 : u-boot 千兆网络功能验证
    网鼎杯初赛--web1
    Dubbo反序列化漏洞分析集合
    【微信小程序】页面tab栏与页面内容联动
    【运维笔记】Docker 部署Kibana-7.4.0（在线Docker版）
    内网穿透的应用-本地部署Stackedit Markdown编辑器公网远程访问
    Flutter Event 派发
    Flink SQL你用了吗？
    Android 透明度设置
    Redis的淘汰策略
  • 原文地址：https://blog.csdn.net/Hai_Helloyou/article/details/133979819