Golang 程序流程控制

程序流程控制介绍

  1. 在程序中，程序运行的流程控制决定程序是如何执行，是我们必须掌握的，主要有三大流程控制语句。

    • 顺序控制
    • 分支控制
    • 循环控制

      顺序控制

      基本介绍

  2. 程序从上到下逐行地运行，中间没有任何判断和跳转。

    顺序控制的注意事项

  3. Golang 中定义变量时采用合法的前向引用。 ```go // 正确案例 func main() { var num1 int = 10 var num int = num1 + 20 fmt.Println(num2) }

// 错误案例 func main() { var num2 int = num1 +20 var num1 int = 10 fmt.Println(num2) }

  1. <a name="ly8d8"></a>
  2. ## 分支控制
  3. <a name="FrDq5"></a>
  4. ### 分支控制 if-else 介绍
  6. 1. 让程序有选择地执行，分支控制有三种： 
  7.    - 单分支 
  8.    - 双分支 
  9.    - 多分支 
  10. <a name="TDZlc"></a>
  11. ### 单分支
  13. 1. 基本语法
  14. ```go
  15. if 条件表达式{
  16.   执行代码块
  17. }
  1. 说明：当条件表达式为 true 时，就会执行 {} 的代码。
  2. 注意：{} 是必须有的，就算你只写一行代码。
  3. 案例演示 ```go package main

import “fmt” // fmt 包中提供格式化、输出、输入的函数

func main() {

  1. //编写一个程序，可以输入人的年龄，如果该同志的年龄大于 18 岁，则输出 "你年龄大于18，要对自己的行为负责！"
  2. //分析
  3. //1. 年龄 ==> var age int
  4. //2. 从控制台接收一个输入 fmt.Scanln(&age)
  5. //3. if 判断
  6. var age int
  7. fmt.Println("请输入年龄：")
  8. fmt.Scanln(&age)
  9. if age > 18 {
  10.     fmt.Println("你年龄大于18，要对自己的行为负责！")
  11. }

}

  2. 5. 细节说明：Go 的 if 还用一个强大的地方就是条件判断语句里面允许声明一个变量，这个变量的作用域只能在该条件逻辑块内，其他地方就不起作用了。
  3. 5. 相关案例
  4. ```go
  5. package main
  7. import "fmt" // fmt 包中提供格式化、输出、输入的函数
  10. func main()  {
  11.     // Golang 支持在if中，直接定义一个变量，比如下面
  12.     if age := 20; age > 18 {
  13.         fmt.Println("你年龄大于18，要对自己的行为负责！")
  14.     }
  15. }

双分支

  1. 基本语法

    1. if 条件表达式 {
    2. 执行代码块1
    3. } else {
    4. 执行代码块2
    5. }

  2. 说明：当条件表达式成立，即执行代码块 1 ，否则执行代码块 2 。 {} 也是必须有的。

  3. 相关案例 ```go package main

import “fmt” // fmt 包中提供格式化、输出、输入的函数

func main() { //编写一个程序，可以输入人的年龄，如果该同志的年龄大于 18 岁，则输出”你的年龄大于 18 ，要对自己的行为负责！”。 //否则，输出”你的年龄不大这次放过你了。”

  1. //思路分析
  2. //1. 年龄 ===> var age int
  3. //2. fmt.Scanln 接收
  4. //3. if --- else
  5. var age int
  6. fmt.Println("请输入年龄：")
  7. fmt.Scanln(&age)
  9. if age > 18 {
  10.     fmt.Println("你年龄大于18，要对自己的行为负责！")
  11. } else {
  12.     fmt.Println("你的年龄不大这次放过你了。")
  13. }

}

  2. 4. 单分支和双分支的相关案例
  3. ```go
  4. package main
  6. import "fmt" // fmt 包中提供格式化、输出、输入的函数
  9. func main() {
  10.     var x int  = 4
  11.     var y int = 1
  12.     if x > 2 {
  13.         if y > 2 {
  14.             fmt.Println(x + y)
  15.         } else {
  16.             fmt.Println("atguigu")
  17.         }
  18.     } else{
  19.         fmt.Println("x is =", x)
  20.     }
  21. }

单分支和双分支的练习题

  1. 编写程序，声明 2 个 int32 型变量并赋值。判断两数之和，如果大于等于 50 ，打印”hello world!”。 ```go package main

import “fmt” // fmt 包中提供格式化、输出、输入的函数

func main() { //编写程序，声明 2 个 int32 型变量并赋值。判断两数之和，如果大于等于 50 ，打印”hello world!”。

  1. //分析
  2. //1. 变量
  3. //2. 单分支
  4. var x int32  = 40
  5. var y int32 = 10
  6. if x + y >= 50 {
  7.     fmt.Println("hello world!")
  8. }

}

  2. 2. 编写程序，声明 2 个 float64 型变量并赋值。判断第一个数大于 10.0，且第 2 个数小于 20.0，打印两数之和。
  3. ```go
  4. package main
  6. import "fmt" // fmt 包中提供格式化、输出、输入的函数
  9. func main() {
  10.     //编写程序，声明 2 个 float64 型变量并赋值。判断第一个数大于 10.0，且第 2 个数小于 20.0，打印两数之和。
  12.     //分析
  13.     //1. 变量
  14.     //2. 单分支
  15.     var x float64  = 10.1
  16.     var y float64 = 19.1
  17.     if x > 10.0 && y < 20.0 {
  18.         fmt.Println(x + y)
  19.     }
  20. }
  1. 定义两个变量 int32 ，判断两者的和，是否能被 3 又能被 5 整除，打印提示信息。 ```go package main

import “fmt” // fmt 包中提供格式化、输出、输入的函数

func main() { //定义两个变量 int32 ，判断两者的和，是否能被 3 又能被 5 整除，打印提示信息。

  1. //分析
  2. //1. 变量
  3. //2. 单分支
  4. var x int32  = 10
  5. var y int32 = 20
  6. if (x + y) % 3 == 0 && (x + y) % 5 == 0 {
  7.     fmt.println("x + y 能被 3 整除且能被 5 整除。")
  8. }

}

  2. 4. 判断一个年份是否是闰年，闰年的条件是符合下面两者之一：(1) 年份能被 4 整除，但不能被 100 整除；(2) 能被 400 整除。
  3. ```go
  4. package main
  6. import "fmt" // fmt 包中提供格式化、输出、输入的函数
  9. func main() {
  10.     //判断一个年份是否是闰年，闰年的条件是符合下面两者之一：
  11.     //(1) 年份能被 4 整除，但不能被 100 整除；(2)能被 400 整除
  13.     var year int = 2020
  14.     if (year % 4 == 0 && year % 100 != 0) || year % 400 == 0 {
  15.         fmt.Printf("%v是闰年。", year)
  16.     }
  17. }

多分支

  1. 基本语法

    1. if 条件表达式 {
    2. 执行代码块 1
    3. } else if 条件表达式2 {
    4. 执行代码块 2
    5. }
    6. ...
    7. else {
    8. 执行代码块 n
    9. }

  2. 多分支的判断流程：

    • 先判断条件表达式 1 是否成立。如果为真，就执行代码块 1 。
    • 如果条件表达式 1 为假，就去判断条件表达式 2 是否成立，如果表达式 2 为真，就执行代码块 2 。
    • 依次类推
    • 如果所有的条件表达式不成立，则执行 else 的语句块。
  3. 多分支基本语法的说明：
    • 最后的 else 不是必须的。
    • 多分支只能有一个执行入口。
  4. 多分支的快速入门案例 ```go // 案例一

package main

import “fmt” // fmt 包中提供格式化、输出、输入的函数

func main() { //岳小鹏参加 Golang 考试，他和他的父亲岳不群达成承诺： //如果：成绩为 100 分时，奖励一辆 BMW ； //成绩为 (80, 99] 时，奖励一台 iphone7Plus ； //成绩为 [60, 80] 时，奖励一台 ipad ； //其他时，什么奖励也没有。 //请从键盘输入岳小鹏的期末成绩，并加以判断。

  1. //分析思路
  2. //1. score 分数变量 int
  3. //2. 多分支流程控制
  4. //3. 成绩从键盘输入 fmt.Scanln()
  6. var score int
  7. fmt.Println("请输入成绩：")
  8. fmt.Scanln(&score)
  11. if score == 100 {
  12.     fmt.Println("奖励一辆 BMW")
  13. } else if score > 80 && score <= 99 {
  14.     fmt.Println("奖励一台 iphone7Plus")
  15. } else if score >= 80 && score <= 80 {
  16.     fmt.Println("奖励一台 ipad")
  17. } else {
  18.     fmt.Println("什么奖励也没有")
  19. }

}

  2. ```go
  3. // 案例二
  4. package main
  6. import "fmt" // fmt 包中提供格式化、输出、输入的函数
  9. func main() {
  10.     var b bool = true
  11.     if b == false {
  12.         fmt.Println("a")
  13.     } else if b {
  14.         fmt.Println("b") // b
  15.     } else if !b {
  16.         fmt.Println("c") // c
  17.     } else {
  18.         fmt.Println("d")
  19.     }
  20. }
  1. // 案例三
  2. package main
  4. import (
  5.     "fmt"  // fmt 包中提供格式化、输出、输入的函数
  6.     "math"
  7. )
  11. func main() {
  12.     //求 ax^2 + bx + c = 0 方程的根。a, b, c 分别为函数的参数，如果：b^2 - 4ac > 0，则有两个解；
  13.     // b^2 - 4ac = 0， 则有一个解；b^2 - 4ac < 0，则无解；
  14.     //提示1：x1 = (-b + sqrt(b^2 - 4ac < 0)) / 2a ; x2 = (-b - sqrt(b^2 - 4ac < 0)) / 2a
  15.     //提示2：math.Sqrt(num); 可以求平方根，需要引入 math 包
  17.     //分析思路
  18.     //1. a, b, c 是三个 float64
  19.     //2. 使用到给出的数学公式
  20.     //3. 使用到多分支
  21.     //4. 使用到 math.Sqrt 方法 => 手册
  23.     var a float64 = 3.0
  24.     var b  float64 = 100.0
  25.     var c float64 = 6.0
  28.     m := b * b - 4 * a * c
  29.     //多分支判断
  30.     if m > 0 {
  31.         x1 := (-b + math.Sqrt(m)) / 2 * a
  32.         x2 := (-b - math.Sqrt(m)) / 2 * a
  33.         fmt.Printf("x1 = %v x2 = %v", x1, x2)
  34.     } else if m == 0 {
  35.         x := (-b + math.Sqrt(m)) / 2 * a
  36.         fmt.Printf("x = %v", x)
  37.     } else {
  38.         fmt.Println("方程无解...")
  39.     }
  40. }
  1. //案例四
  2. package main
  4. import "fmt" // fmt 包中提供格式化、输出、输入的函数
  7. func main() {
  9.     // 大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定条件：高 180 cm 以上；富：财富 1 千万以上；帅：是。 条件从控制台输入。
  10.     // 1. 如果这三个条件同时满足，则："我一定要嫁给他！！！"。
  11.     // 2. 如果三个条件有为真的情况，则："嫁吧，比上不足，比下有余。"
  12.     // 3. 如果三个条件都不满足，则："不嫁！"
  14.     //分析思路
  15.     //1. 应该设计三个变量 var height int32 | var money float32 | var handsome bool
  16.     //2. 而且需要从终端输入 fmt.Scanln
  17.     //3. 使用多分支
  18.     var height int32
  19.     var money float32
  20.     var handsome bool
  22.     fmt.Println("请输入身高(厘米)")
  23.     fmt.Scanln(&height)
  24.     fmt.Println("请输入财富(千万)")
  25.     fmt.Scanln(&money)
  26.     fmt.Println("请输入是否帅(true/false)")
  27.     fmt.Scanln(&handsome)
  29.     if height > 180 && money > 1.0 && handsome == true {
  30.         fmt.Println("我一定要嫁给他！！！")
  31.     } else if height > 180 || money > 1.0 || handsome == true {
  32.         fmt.Println("嫁吧，比上不足，比下有余。")
  33.     } else {
  34.         fmt.Println("不嫁！")
  35.     }
  36. }

嵌套分支

基本介绍

  1. 在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支结构称为内层分支外面的分支称为外层分支。

  2. 基本语法

    1. if 条件表达式 {
    2. if 条件表达式 {
    3. } else {
    4. }
    5. }

  3. 说明：嵌套分支不宜过多，建议控制在 3 层内。

  4. 相关案例 ```go //案例一 package main

import “fmt” // fmt 包中提供格式化、输出、输入的函数

func main() {

  1. //参加百米运动会，如果勇士 8 秒内进入决赛，否则提示淘汰。并根据性别提示进入男子组或女子组。
  2. //输入成绩和性别。
  4. //分析思路
  5. //1. 定义一个变量，来接收跑步的秒数，flaot64 。
  6. //2. 定义一个变量，来接收性别 string
  7. //3. 因为判断是嵌套的判断，因此我们会使用嵌套分支。
  9. var second float64
  10. fmt.Println("请输入秒数：")
  11. fmt.Scanln(&second)
  14. if second <= 8 {
  15.     //进入决赛
  16.     var gender string
  17.     fmt.Println("请输入性别：")
  18.     fmt.Scanln(&gender)
  19.     if gender == "男" {
  20.         fmt.Println("进入决赛的男子组")
  21.     } else {
  22.         fmt.Println("进入决赛的女子组")
  23.     }
  24. } else {
  25.     fmt.Println("out...")
  26. }

}

  2. ```go
  3. //案例二
  4. package main
  6. import "fmt" // fmt 包中提供格式化、输出、输入的函数
  9. func main() {
  11.     /*
  12.     出票系统：根据淡旺季的月份和年龄，打印票价
  14.     旺季(4-10)：
  15.         成人(18-60)：60
  16.         儿童(<18)：半价
  17.         老人(>60)：1/3
  19.     淡季：
  20.         成人：40
  21.         其他：20
  22.     */
  24.     //分析思路
  25.     //1. month age 的两个变量 byte
  26.     //2. 使用嵌套分支。
  28.     var month byte
  29.     var age byte
  30.     var price float64 = 60.0
  31.     fmt.Println("请输入旅游的月份：")
  32.     fmt.Scanln(&month)
  33.     fmt.Println("请输入游客的年龄：")
  34.     fmt.Scanln(&age)
  36.     if month >= 4 && month <= 10 {
  37.         if age > 60 {
  38.             fmt.Printf("票价：%v", price / 3)
  39.         } else if age >= 18 {
  40.             fmt.Printf("票价：%v", price)
  41.         } else {
  42.             fmt.Printf("票价：%v", price / 2)
  43.         }
  44.     } else {
  45.         //淡季
  46.         if age >= 18 && age <= 60 {
  47.             fmt.Printf("票价：%v", 40)
  48.         } else {
  49.             fmt.Printf("票价：%v", 20)
  50.         }
  51.     }
  52. }

switch 分支结构

switch 分支的基本介绍

  1. switch 语句用于基于不同条件执行不同动作，每个 case 分支都是唯一的，从上到下逐一测试，直到匹配为止。
  2. 匹配项后面也不需要再加 break 。

    switch 分支的基本语法

    1. switch 表达式 {
    2. case 表达式1,表达式2,...:
    3. 语句块1
    4. case 表达式3,表达式4,...:
    5. 语句块2
    6. // 这里可以有多个 case 语句
    7. default:
    8. 语句块
    9. }

    switch 的快速入门案例

    ```go package main

import “fmt” // fmt 包中提供格式化、输出、输入的函数

func main() {

  1. /*
  2.     案例：
  3.     请编写一个程序，该程序可以接收一个字符，比如：a, b, c, d, e, f, g。
  4.     a 表示星期一，b 表示星期二...。根据用户的输入显示相应的信息。
  5.     要求使用 switch 语句完成
  8.     分析思路：
  9.     1. 定义一个变量接受字符。
  10.     2. 使用 switch 完成。
  12. */
  14. var key byte
  15. fmt.Println("请输入一个字符 a, b, c, d, e, f, g:")
  16. fmt.Scanf("%c", &key)
  18. switch key {
  19.     case 'a':
  20.         fmt.Println("周一，猴子穿新衣")
  21.     case 'b':
  22.         fmt.Println("周二，猴子当小二")
  23.     case 'c':
  24.         fmt.Println("周三，猴子爬雪山")
  25.     //...
  26.     default:
  27.         fmt.Println("输入有误...")
  28. }

}

  1. <a name="b9Z4F"></a>
  2. ### switch 细节讨论
  4. 1. case/switch 后是一个表达式(即：常量值、变量、一个有返回值的函数等都可以)。
  5. ```go
  6. //案例一
  7. package main
  9. import "fmt" // fmt 包中提供格式化、输出、输入的函数
  12. func main() {
  14.     /*
  15.         案例：
  16.         请编写一个程序，该程序可以接收一个字符，比如：a, b, c, d, e, f, g。
  17.         a 表示星期一，b 表示星期二...。根据用户的输入显示相应的信息。
  18.         要求使用 switch 语句完成
  21.         分析思路：
  22.         1. 定义一个变量接受字符。
  23.         2. 使用 switch 完成。
  25.     */
  27.     var key byte
  28.     fmt.Println("请输入一个字符 a, b, c, d, e, f, g: ")
  29.     fmt.Scanf("%c", &key)
  31.     switch 'a' {
  32.     case 'a':
  33.         fmt.Println("周一，猴子穿新衣")
  34.     case 'b':
  35.         fmt.Println("周二，猴子当小二")
  36.     case 'c':
  37.         fmt.Println("周三，猴子爬雪山")
  38.     //...
  39.     default:
  40.         fmt.Println("输入有误...")
  41.     }
  42. }
  1. //案例二
  2. package main
  4. import "fmt" // fmt 包中提供格式化、输出、输入的函数
  7. //写一个非常简单的函数
  8. func test(char byte) byte {
  9.     return char + 1
  10. }
  12. func main() {
  14.     /*
  15.         案例：
  16.         请编写一个程序，该程序可以接收一个字符，比如：a, b, c, d, e, f, g。
  17.         a 表示星期一，b 表示星期二...。根据用户的输入显示相应的信息。
  18.         要求使用 switch 语句完成
  21.         分析思路：
  22.         1. 定义一个变量接受字符。
  23.         2. 使用 switch 完成。
  25.     */
  27.     var key byte
  28.     fmt.Println("请输入一个字符 a, b, c, d, e, f, g:")
  29.     fmt.Scanf("%c", &key)
  31.     switch test(key) + 1 {
  32.     case 'a':
  33.         fmt.Println("周一，猴子穿新衣")
  34.     case 'b':
  35.         fmt.Println("周二，猴子当小二")
  36.     case 'c':
  37.         fmt.Println("周三，猴子爬雪山")
  38.     //...
  39.     default:
  40.         fmt.Println("输入有误...")
  41.     }
  42. }
  1. case 后的各个表达式的值的数据类型，必须和 switch 的表达式数据类型一致。 ```go //案例一 package main

import “fmt” // fmt 包中提供格式化、输出、输入的函数

func main() { var n1 int32 = 20 var n2 int32 = 20

  1. switch n1 {
  2.     case n2 :
  3.         fmt.Println("ok1")
  4.     default :
  5.         fmt.Println("没有匹配到")
  6. }

}

  2. 3. case 后面可以带多个表达式，使用逗号间隔。比如 case 表达式1，表达式2...。
  3. ```go
  4. //案例一
  5. package main
  7. import "fmt" // fmt 包中提供格式化、输出、输入的函数
  10. func main() {
  12.     var n1 int32 = 20
  13.     var n2 int32 = 20
  15.     switch n1 {
  16.     case n2, 10, 5: // case 后面可以有多个表达式
  17.         fmt.Println("ok1")
  18.     default :
  19.         fmt.Println("没有匹配到")
  20.     }
  21. }
  1. case 后面的表达式如果是常量值(字面量)，则要求不能重复。 ```go //案例一 package main

import “fmt” // fmt 包中提供格式化、输出、输入的函数

func main() {

  1. var n1 int32 = 20
  2. var n2 int32 = 20
  3. var n3 int32 = 20
  6. switch n1 {
  7. case n2, 10, 5: // case 后面可以有多个表达式
  8.     fmt.Println("ok1")
  9. //case 5 : //错误，因为前面我们有这个常量 5 ，因此重复，就会报错。
  10.     //fmt.Println("ok2")
  11. case n3:
  12.     fmt.Println("ok2")
  13. default :
  14.     fmt.Println("没有匹配到")
  15. }

}

  2. 5. case 后面不需要带 break ，程序匹配到一个 case 后就会执行对应的代码块，然后退出 switch ，如果一个匹配不到，则执行 default 。
  3. ```go
  4. // 案例一
  5. package main
  7. import "fmt" // fmt 包中提供格式化、输出、输入的函数
  10. func main() {
  12.     var n1 int32 = 51
  13.     var n2 int32 = 20
  16.     switch n1 {
  17.     case n2, 10, 5: // case 后面可以有多个表达式
  18.         fmt.Println("ok1")
  19.     case 90:
  20.         fmt.Println("ok2")
  22.     }
  23. }
  1. default 语句不是必须的。
  2. switch 后也可以不带表达式，类似于 if-else 分支来使用。 ```go //案例一 package main

import “fmt” // fmt 包中提供格式化、输出、输入的函数

func main() {

  1. //switch 后也可以不带表达式，类似if--else分支来使用。
  2. var age int = 10
  4. switch {
  5.     case age == 10 :
  6.         fmt.Println("age == 10")
  7.     case age == 20 :
  8.         fmt.Println("age == 20")
  9.     default :
  10.         fmt.Println("没有匹配到")
  11. }

}

  2. ```go
  3. //案例二
  4. package main
  6. import "fmt" // fmt 包中提供格式化、输出、输入的函数
  9. func main() {
  11.     // switch 后也可以不带表达式，类似 if--else 分支来使用。
  12.     // case 中也可以对范围进行判断
  13.     var score int = 90
  15.     switch {
  16.         case score > 90 :
  17.             fmt.Println("成绩优秀..")
  18.         case score >= 70 :
  19.             fmt.Println("成绩优良..")
  20.         case score >= 60 :
  21.             fmt.Println("成绩及格..")
  22.         default :
  23.             fmt.Println("不及格")
  24.     }
  25. }
  1. switch 后也可以直接声明/定义一个变量，分号结束，不推荐。 ```go //案例一 package main

import “fmt” // fmt 包中提供格式化、输出、输入的函数

func main() {

  1. //switch 后也可以直接声明/定义一个变量，分号结束，不推荐
  3. switch grade := 90; {
  4.     case grade > 90 :
  5.         fmt.Println("成绩优秀..")
  6.     case grade >= 70 :
  7.         fmt.Println("成绩优良..")
  8.     case grade >= 60 :
  9.         fmt.Println("成绩及格..")
  10.     default :
  11.         fmt.Println("不及格")
  12. }

}

  2. 9. switch 穿透- fallthrough ，如果在 case 语句块后增加 fallthrough ，则会继续执行下一个 case ，也叫 switch 穿透。
  3. ```go
  4. //案例一
  5. package main
  7. import "fmt" // fmt 包中提供格式化、输出、输入的函数
  10. func main() {
  12.     //switch 的穿透 fallthrough
  13.     var num int = 10
  15.     switch num {
  16.         case 10 :
  17.             fmt.Println("ok1")
  18.             fallthrough //默认只能穿透一层
  19.         case 20 :
  20.             fmt.Println("ok2")
  21.         case 30 :
  22.             fmt.Println("ok3")
  23.         default :
  24.             fmt.Println("没有匹配到...")
  25.     }
  26. }
  1. Type Switch：switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际指向的变量类型。 ```go // 案例一 package main

import “fmt”

func main() {

  1. var x interface{}
  2. var y = 10.0
  3. x = y
  5. switch i := x.(type){
  6. case nil :
  7.     fmt.Printf("x 的类型~ :%T", i)
  8. case int :
  9.     fmt.Printf("x 是 int 型")
  10. case float64 :
  11.     fmt.Printf("x 是 float64 型")
  12. case bool, string :
  13.     fmt.Printf("x 是 bool 或是 string 型")
  14. default :
  15.     fmt.Printf("未知型")
  16. }

}

  1. <a name="NCA4k"></a>
  2. ### switch 练习
  4. 1. 练习一
  5. ```go
  6. package main
  8. import "fmt"
  11. func main() {
  12.     /*
  13.     1. 使用 switch 把小写类型的 char 型转为大写(键盘输入)。
  14.     2. 只转换 a, b, c, d, e。其他的输出 "other" 。
  15.     */
  16.     var char byte
  17.     fmt.Println("请输入一个字符..")
  18.     fmt.Scanf("%c", &char)
  20.     switch char {
  21.         case 'a' :
  22.             fmt.Println("A")
  23.         case 'b' :
  24.             fmt.Println("B")
  25.         case 'c' :
  26.             fmt.Println("C")
  27.         case 'd' :
  28.             fmt.Println("D")
  29.         case 'e' :
  30.             fmt.Println("E")
  31.         default :
  32.             fmt.Println("other")
  33.     }
  34. }
  1. 练习二 ```go package main

import “fmt”

func main() { /*

  1. 1. 对学生成绩大于 60 分，输出"合格"。低于 60 分，输出"不合格"。
  2. 2. (注：输入的成绩不能大于 100)
  3. */
  5. var score float64
  6. fmt.Println("请输入成绩：")
  7. fmt.Scanln(&score)
  9. switch int(score / 60) {
  10.     case 1 :
  11.         fmt.Println("及格")
  12.     case 0 :
  13.         fmt.Println("不及格")
  14.     default :
  15.         fmt.Println("输入有误..")
  16. }

}

  2. 3. 练习三
  3. ```go
  4. package main
  6. import "fmt"
  9. func main() {
  11.         /*
  12.         1. 根据用户指定月份，打印该月份所属的季节。
  13.         2. 3，4，5 春季；6，7，8 夏季；9，10，11 秋季；12，1，2 冬季。
  14.         */
  16.         var month byte
  17.         fmt.Println("请输入月份：")
  18.         fmt.Scanln(&month)
  20.     switch month {
  21.         case 3, 4, 5 :
  22.             fmt.Println("spring")
  23.         case 6, 7, 8 :
  24.             fmt.Println("summer")
  25.         case 9, 10, 11 :
  26.             fmt.Println("autumn")
  27.         case 12, 1, 2:
  28.             fmt.Println("winter")
  29.         default:
  30.             fmt.Println("输入有误..")
  31.     }
  32. }
  1. 练习四 ```go package main

import “fmt”

func main() {

  1. /*
  2. 1. 根据用户输入显示对应的的星期时间(string)。
  3. 2. 如果是"星期一"，显示"干煸豆角"；如果是"星期二"，显示"酸溜土豆"；
  4. 3. 如果"星期三"，显示"红烧狮子头"；如果是"星期四"，显示"油炸花生米"；
  5. 4. 如果是"星期五"，显示"蒜蓉扇贝"；如果是"星期六"，显示"东北乱炖"；如果是"星期日"，显示"大盘鸡"。
  6. */
  8. var today string
  9. fmt.Println("请输入今天星期几：")
  10. fmt.Scanln(&today)
  12. switch today {
  13. case "星期一" :
  14.     fmt.Println("干煸豆角")
  15. case "星期二" :
  16.     fmt.Println("酸溜土豆")
  17. case "星期三" :
  18.     fmt.Println("红烧狮子头")
  19. case "星期四" :
  20.     fmt.Println("油炸花生米")
  21. case "星期五" :
  22.     fmt.Println("蒜蓉扇贝")
  23. case "星期六" :
  24.     fmt.Println("东北乱炖")
  25. case "星期日" :
  26.     fmt.Println("大盘鸡")
  27. default :
  28.     fmt.Println("输入有误..")
  29. }

}

  1. <a name="SzbKD"></a>
  2. ### switch 和 if 的比较
  4. 1. 如果判断的具体数值不多，而且符合整数、浮点数、字符、字符串这几种类型。建议使用 switch 语句，简洁高效。
  5. 1. 其他情况：结果为 bool 类型的判断，使用 if ，if 的使用范围更广。
  6. <a name="MHsSV"></a>
  7. ## for 循环
  8. <a name="LnX6B"></a>
  9. ### for 循环的基本介绍
  11. 1. 听其名而知其意，就是让我们的一段代码循环的执行。
  12. <a name="Thbup"></a>
  13. ### for 循环的快速入门
  14. ```go
  15. package main
  17. import "fmt"
  19. func main() {
  20.     //输出十句，"你好，尚硅谷！"
  21.     //fmt.Println("你好，尚硅谷！")
  22.     //fmt.Println("你好，尚硅谷！")
  23.     //fmt.Println("你好，尚硅谷！")
  24.     //fmt.Println("你好，尚硅谷！")
  25.     //fmt.Println("你好，尚硅谷！")
  26.     //
  27.     //fmt.Println("你好，尚硅谷！")
  28.     //fmt.Println("你好，尚硅谷！")
  29.     //fmt.Println("你好，尚硅谷！")
  30.     //fmt.Println("你好，尚硅谷！")
  31.     //fmt.Println("你好，尚硅谷！")
  33.     // Golang 中，有循环控制语句来处理循环的执行某段代码的方法 ==> for 循环
  34.     //for 循环快速入门
  36.     for i := 1; i <= 10; i++ {
  37.         fmt.Println("你好，尚硅谷！", i)
  38.     }
  39. }

for 循环

  1. 语法格式

    1. for 循环变量初始化；循环条件；循环变量迭代 {
    2. 循环操作(语句)
    3. }

  2. 对 for 循环来说，有四个要素

    • 循环变量初始化
    • 循环条件
    • 循环操作语句
    • 循环变量迭代

  3. for 循环执行的顺序说明

    • 执行循环变量初始化，比如 i := 1
    • 执行循环条件，比如 i <= 10
    • 如果循环条件为真，就执行循环操作。 比如：fmt.Println(“…”)
    • 执行循环变量迭代，比如 i++
    • 反复执行 2，3，4 步骤，直到循环条件为 False，就退出 for 循环。

      for 循环的注意事项和细节说明

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

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

    1. for 循环条件 {
    2. //循环执行语句
    3. }
    4. //将变量初始化和变量迭代写到其他位置。

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

    1. for {
    2. //循环执行语句
    3. }
    4. // 上面的写法等价 for;;{} 是一个无限循环，通常需要配合 break 语句使用。

  7. Golang 提供 for-range 的方式，可以方便遍历字符串和数组。 ```go package main

import “fmt”

func main() {

  1. //字符串遍历方式一(传统方式)
  2. var str string = "hello,world"
  3. for i := 0; i < len(str); i++ {
  4.     fmt.Printf("%c \n", str[i]) //使用到下标
  5. }
  8. //字符串遍历方式二( for-range 方式)
  9. str = "abc~ok"
  10. for index, val := range str {
  11.     fmt.Printf("index = %d, val = %c \n", index, val)
  12. }

}

  2. 5. 上面代码细节讨论 
  3.    - 如果我们的字符串含有中文，那么传统的遍历字符串方式，就是错误，会出现乱码。原因是：传统的对字符串的遍历是按照字节来遍历，而一个汉字在 utf-8 编码是对应 3 个字节。 
  4.    - 只需要将 str 转成 []rune 切片 
  5.    - 对应 for-range 遍历而言，是按照字符方式遍历。因此如果有字符串有中文，也是 ok 。 
  6. 6. 具体案例 
  7. ```go
  8. package main
  10. import "fmt"
  12. func main() {
  14.     //字符串遍历方式一(传统方式)
  15.     var str string = "hello,world!北京"
  16.     str2 := []rune(str) //就是把 str 转成 []rune
  17.     for i := 0; i < len(str2); i++ {
  18.         fmt.Printf("%c \n", str2[i]) //使用到下标
  19.     }
  22.     //字符串遍历方式二( for-range 方式)
  23.     str = "abc~ok上海"
  24.     for index, val := range str {
  25.         fmt.Printf("index = %d, val = %c \n", index, val)
  26.     }
  27. }

for 循环练习

  1. 练习一 ```go package main

import “fmt”

func main() { //打印 1~100 之间所有是 9 的倍数的整数的个数及总和。

  1. //分析思路
  2. //1. 使用 for 循环对 max 进行遍历
  3. //2. 当一个数 %9==0 就是 9 的倍数
  4. //3. 我们需要声明两个变量 count 和 sum 来保存个数和总和
  5. var max uint64 = 100
  6. var count uint64 = 0
  7. var sum uint64 = 0
  8. var i uint64 = 0
  10. for ; i <= max; i++ {
  11.     if i % 9 == 0 {
  12.         count ++
  13.         //sum = sum + i
  14.         sum += i
  15.     }
  16. }
  17. fmt.Printf("count = %v sum = %v \n", count, sum)

}

  2. 2. 练习二
  3. ```go
  4. package main
  6. import "fmt"
  9. func main() {
  10.     var n int = 6
  11.     for i := 0; i <= n; i++ {
  12.         fmt.Printf("%v + %v = %v \n", i, n-i, n)
  13.     }
  14. }

while 和 do…while 的实现

for 循环实现 while 的效果

  1. 基本语法

    1. 循环变量初始化
    2. for {
    3. if循环表达式{
    4.  break // 跳出 for 循环..
    5. }
    6. 循环操作(语句)
    7. 循环变量迭代
    8. }

  2. 基本语法说明

    • for 循环是一个无限循环
    • break 语句就是跳出 for 循环

      for 循环实现 do…while 的效果

  3. 基本语法

    1. 循环变量初始化
    2. for {
    3. 循环操作(语句)
    4. 循环变量迭代
    5. if 循环条件表达式 {
    6.  break // 跳出 for 循环...
    7. }
    8. }

  4. 基本语法的说明

    • 上面的循环是先执行，再判断，因此至少执行一次。
    • 当循环条件成立后，就会执行 break ，break 就是跳出 for 循环，结束循环。

      多重循环控制

  5. 将一个循环放在另一个循环体内，就形成了嵌套循环。在外边的 for 称为外层循环在里面的 for 循环称为内层循环。

  6. 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。

  7. 设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m x n 次。

    多重循环控制相关案例

  8. 案例一 ```go package main

import “fmt”

func main() { //应用案例 //1. 统计 3 个班的成绩情况，每个班有 5 名同学。 //2. 求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]

  1. //编程时两大绝招
  2. //1. 先易后难，即将一个复杂的问题分解成简单的问题。
  3. //2. 先死后活，先把程序写死，再用变量灵活替换。
  5. //分析实现思路1
  6. //1. 统计 1 个班成绩情况，每个班有5名同学，求出该班的平均分[学生的成绩从键盘输入] ==> [先易后难]
  7. //2. 学生数就是 5 个 ==> [先死后活]
  8. //3. 声明一个 sum 统计班级总分
  10. //分析实现思路1：代码实现
  11. //class_sum := 0.0
  12. //for j := 1; j <= 5; j++ {
  13. //    var score float64
  14. //    fmt.Printf("请输入第 %d 学生成绩：\n", j)
  15. //    fmt.Scanln(&score)
  16.     //累计总分
  17. //    class_sum = class_sum + score
  18. //}
  19. //fmt.Printf("班级的平均分为：%v \n", class_sum / 5)
  21. //分析实现思路2
  22. //1. 统计三个班成绩情况，每个班有 5 名同学，求出每个班的的平均分[学生的成绩从键盘输入]
  23. //2. i 表示第几个班级
  24. //3. 定义一个变量存放总成绩
  26. //分析实现思路2：代码实现方式
  27. //var total_sum float64 = 0.0
  28. //
  29. //for i := 1; i <= 3; i++ {
  30. //    class_sum := 0.0
  31. //    for j := 1; j <= 5; j++ {
  32. //        var score float64
  33. //        fmt.Printf("请输入第 %d 班 第 %d 学生成绩：\n", i, j)
  34. //        fmt.Scanln(&score)
  35. //        class_sum = class_sum + score
  36. //    }
  37. //    fmt.Printf("第 %d 个班级的平均分为：%v \n", i, class_sum / 5)
  38. //    //将各个班的总成绩累计到 total_sum
  39. //    total_sum = total_sum + class_sum
  40. //}
  41. //fmt.Printf("各个班级的总成绩 %v 所有班级平均分为：%v \n", total_sum, total_sum / (3 * 5))
  43. //分析实现思路3
  44. //1. 我们可以把代码做活
  45. //2. 定义两个变量，表示班级的个数和班级的人数。
  47. var class_num int = 3
  48. var student_num int = 5
  49. var total_sum float64 = 0.0
  51. for i := 1; i <= class_num; i++ {
  52.     class_sum := 0.0
  53.     for j := 1; j <= student_num; j++ {
  54.         var score float64
  55.         fmt.Printf("请输入第 %d 班 第 %d 学生成绩：\n", i, j)
  56.         fmt.Scanln(&score)
  57.         class_sum = class_sum + score
  58.     }
  59.     fmt.Printf("第%d个班级的平均分为：%v \n", i, class_sum / float64(student_num))
  60.     //将各个班的总成绩累计到total_sum
  61.     total_sum = total_sum + class_sum
  62. }
  63. fmt.Printf("各个班级的总成绩 %v 所有班级平均分为：%v \n", total_sum, total_sum / float64(class_num * student_num))

}

  2. 2. 案例二
  3. ```go
  4. package main
  6. import "fmt"
  8. func main() {
  9.     //应用案例
  10.     //统计三个班及格人数，每个班有 5 名同学
  11.     //分析思路
  12.     //1. 声明一个变量 pass_count 用于保存及格人数
  14.     var class_num int = 3
  15.     var student_num int = 5
  16.     var total_sum float64 = 0.0
  17.     var pass_count int = 0
  19.     for i := 1; i <= class_num; i++ {
  20.         class_sum := 0.0
  21.         for j := 1; j <= student_num; j++ {
  22.             var score float64
  23.             fmt.Printf("请输入第 %d 班 第 %d 学生成绩：\n", i, j)
  24.             fmt.Scanln(&score)
  25.             class_sum = class_sum + score
  26.             //判断分数是否及格
  27.             if score >= 60 {
  28.                 pass_count++
  29.             }
  30.         }
  31.         fmt.Printf("第 %d 个班级的平均分为：%v \n", i, class_sum / float64(student_num))
  32.         //将各个班的总成绩累计到 total_sum
  33.         total_sum = total_sum + class_sum
  34.     }
  35.     fmt.Printf("各个班级的总成绩 %v 所有班级平均分为：%v \n", total_sum, total_sum / float64(class_num * student_num))
  36.     fmt.Printf("及格人数为 %v \n", pass_count)
  37. }
  1. 案例三 ```go package main

import “fmt”

func main() { //应用案例 //使用 for 循环完成下面的案例：请编写一个案例，可以接收一个整数，打印出金字塔。

  1. //编程思路
  2. //1. 打印一个矩形
  3. /*
  4.  ***
  5.  ***  ==> 矩形
  6.  ***
  7. */
  9. //2. 打印半个金字塔
  10. /*
  11.  *        1 个 *
  12.  **        2 个 *
  13.  ***    3 个 *
  14. */
  16. //3. 打印整个金字塔
  17. /*
  18.     *          1层 1 个*    规律：2 * 层数 -1        空格 2    规律：总层数 - 当前层数
  19.    ***        2层 3 个*    规律：2 * 层数 -1        空格 1    规律：总层数 - 当前层数
  20.   *****        3层 4 个*    规律：2 * 层数 -1        空格 0    规律：总层数 - 当前层数
  21. */
  23. //4. 将层数做成一个变量即可
  24. // var total_level int = 3
  26. //5. 打印空心金字塔
  27. /*
  28.     *
  29.    * *
  30.   *   *
  31. 分析：在我们给每行打印 * 号，需要考虑是打印 * 还是打印 空格
  32. 分析结果是：每层的第一个和最后一个是打印 * ，其他就应该是空，即输出空格。
  33. 分析到一个例外情况，底层全部打 *
  34. */
  35. var total_level int = 3
  36. //i 表示层数
  37. for i := 1; i <= total_level; i++ {
  38.     //在打印*前先打印空格
  39.     for k := 1; k <= total_level - i; k++ {
  40.         fmt.Print(" ")
  41.     }    //j 表示每层打印多少 *
  42.         for j := 1; j <= 2 * i - 1; j++ {
  43.             if j == 1 || j == 2 * i - 1 || i == total_level {
  44.                 fmt.Print("*")
  45.             } else {
  46.                 fmt.Print(" ")
  47.             }
  48.         }
  49.         fmt.Println()
  50. }

}

  2. 4. 案例四
  3. ```go
  4. package main
  6. import "fmt"
  8. func main() {
  9.     //打印出九九乘法表
  10.     //i 表示层数
  11.     var num int = 9
  12.     for i := 1; i <= num; i ++ {
  13.         for j := 1; j <= i; j ++ {
  14.             fmt.Printf("%v * %v = %v \t", j, i, j * i)
  15.         }
  16.         fmt.Println()
  17.     }
  18. }

跳转控制语句 - break

快速入门

  1. package main
  3. import (
  4.     "fmt"
  5.     "math/rand"
  6.     "time"
  7. )
  9. func main() {
  10.     //案例
  11.     //随机生成 1-100 的一个数，知道生成了 99 整数，看看你一共用了几次
  13.     //分析：编写一个无限循环的控制，然后不停的随机生成树，当生成了 99 时，就退出这个无限循环 ==> break
  15.     //我们为了生成一个随机数，还需要个 rand 设置一个种子
  16.     //time.Now().Unix(): 返回一个从 1970:01:01 的 0 时 0 分 0 秒到现在的秒数
  17.     //如何随机的生成 1-100 的整数
  18.     //rand.Seed(time.Now().Unix())
  19.     //n := rand.Intn(100) + 1  // [0，100)
  20.     //fmt.Println(n)
  22.     var count int = 0
  23.     for {
  24.         rand.Seed(time.Now().UnixNano())
  25.         n := rand.Intn(100) + 1  // [0，100)
  26.         fmt.Println("n =", n)
  27.         count ++
  28.         if n == 99 {
  29.             break //表示跳出for循环
  30.         }
  31.     }
  32.     fmt.Printf("生成 99 一共使用了 %v 次 \n", count)
  33. }

基本介绍

  1. break 语句用于终止某个语句块的执行，用于中断当前 for 循环或跳出 switch 语句。

    基本语法

    1. { ...
    2. break;
    3. ...
    4. }

    注意事项和细节说明

  2. break 语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块。

  3. 相关案例 ```go package main

import “fmt”

func main() { //案例 //这里演示以下指定标签的形式来使用 break label2: for i := 0; i < 4; i++ { //label1: // 设置一个标签 for j := 0; j < 10; j++ { if j == 2 { //break // break 默认会跳出最近的 for 循环 //break label1 break label2 } fmt.Println(“j = “, j) } } }

  2. 3. 对上面案例的说明 
  3.    - break 默认会跳出最近的 for 循环 
  4.    - break 后面可以指定标签，跳出标签对应的 for 循环。 
  5. 4. 相关练习 
  6. ```go
  7. //练习一
  8. package main
  10. import "fmt"
  13. func main() {
  14.     //100以内的数求和，求出 当和 第一次大于 20 的当前数。
  15.     sum := 0
  16.     for i := 1; i <= 100; i++ {
  17.         sum += i // 求和
  18.         if sum > 20 {
  19.             fmt.Printf("当 sum > 20 ，当前数是 %v \n", i)
  20.             break
  21.         }
  22.     }
  23. }
  1. package main
  3. import "fmt"
  5. func main() {
  6.     //实现登录验证，有三次机会，如果用户名为"张无忌"，密码 "888" 提示登录成功，否则提示还有几次机会。
  8.     var name string
  9.     var pwd string
  11.     var loginChance int = 3
  13.     for i := 1; i <= 3; i++ {
  14.         fmt.Println("请输入用户名：")
  15.         fmt.Scanln(&name)
  16.         fmt.Println("请输入密码：")
  17.         fmt.Scanln(&pwd)
  19.         if name == "张无忌" && pwd == "888" {
  20.             fmt.Println("登录成功")
  21.             break
  22.         } else {
  23.             loginChance--
  24.             if loginChance > 0 {
  25.                 fmt.Printf("你还有 %v 登录机会，请珍惜 \n", loginChance)
  26.             } else {
  27.                 fmt.Println("机会用完，没有登录成功")
  28.             }
  29.         }
  30.     }
  31. }

跳转控制语句 - continue

基本介绍

  1. continue 语句用于结束本次循环，继续执行下一次循环。
  2. continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签使用的规则一样。

  3. 基本语法

    1. { ...
    2. continue;
    3. ...
    4. }

  4. 相关案例 ```go package main

import “fmt”

func main() { // continue 案例 label2: for i := 0; i < 4; i++ { //label1: // 设置一个标签 for j := 0; j < 10; j++ { if j == 2 { //continue continue label2 } fmt.Println(“j =”, j) } } }

  2. 5. 相关练习
  3. ```go
  4. //练习一
  5. package main
  7. import "fmt"
  9. func main() {
  10.     for i := 0; i < 2; i++ {
  11.         for j :=1; j < 4; j++ {
  12.             if j == 2 {
  13.                 continue;
  14.             }
  15.             fmt.Println("i =", i, "j =", j)
  16.         }
  17.     }
  18. }
  1. //练习二
  2. package main
  4. import "fmt"
  7. func main() {
  8.     here:
  9.     for i := 0; i < 2; i++ {
  10.         //here:
  11.         for j := 1; j < 4; j++ {
  12.             if j == 2 {
  13.                 continue here
  14.             }
  15.             fmt.Println("i =", i ,"j =", j)
  16.         }
  17.     }
  18. }
  1. //练习三
  2. package main
  4. import "fmt"
  6. func main()  {
  7.     // 练习
  8.     /*
  9.     continue 实现打印 1-100 之内的奇数[要求使用 for 循环 + continue ]
  10.     */
  12.     fmt.Println("1-100 之内的奇数如下所示：")
  13.     for i := 1; i <= 100; i++ {
  14.         if i % 2 == 0 {
  15.             continue
  16.         }
  17.         fmt.Println(i)
  18.     }
  19. }
  1. //练习四
  2. package main
  4. import "fmt"
  6. func main() {
  7.     //从键盘读取个数不确定的整数，并判断读入的正数和负数的个数，输入位0时结束程序。
  8.     var positiveCount int //正数个数
  9.     var negativeCount int //负数个数
  10.     var num int
  11.     for {
  12.         fmt.Println("请输入一个整数：")
  13.         fmt.Scanln(&num)
  15.         if num == 0 {
  16.             break // 终止 for 循环
  17.         }
  18.         if num > 0 {
  19.             positiveCount++
  20.             continue // 结束本次循环，进入下次循环
  21.         }
  22.         negativeCount++
  23.     }
  24.     fmt.Printf("正数个数是 %v 负数的个数是 %v", positiveCount, negativeCount)
  25. }

跳转控制语句 - goto

基本介绍

  1. Go 语言的 goto 语句可以无条件地转移到程序中指定的行。
  2. goto 语句通常与条件控制语句配合使用。可用来实现条件转移，跳出循环体等功能。
  3. 在 Go 程序设计中一般不主张使用 goto 语句，以免造成程序的混乱，使理解和调试程序都产生困难。

    基本语法

    1. goto label
    2. ...
    3. label:statement

    快速入门案例

    ```go package main

import “fmt”

func main() {

  1. //演示 goto 的使用
  2. //goto 一般配合 if 语句使用
  3. //尽量避免使用 goto 语句
  5. var n int = 30
  6. fmt.Println("ok1")
  8. if n > 20 {
  9.     goto label1
  10. }
  12. fmt.Println("ok2")
  13. fmt.Println("ok3")
  14. fmt.Println("ok4")
  15. label1:
  16. fmt.Println("ok5")
  17. fmt.Println("ok6")
  18. fmt.Println("ok7")

}

  1. <a name="qEkFV"></a>
  2. ### 跳转控制语句 - return
  3. <a name="BmbMa"></a>
  4. #### 基本介绍
  6. 1. return 使用在方法或者函数中，表示跳出所在的方法或函数。
  7. 1. 说明：如果 return 是在普通的函数中，则表示跳出该函数，即不再执行函数中 return 后面代码，也可以理解成终止函数；如果 return 是在 main 函数，表示终止 main 函数，也就是说终止程序。
  8. <a name="Hdk8E"></a>
  9. #### 快速入门案例
  10. ```go
  11. package main
  13. import "fmt"
  16. func main() {
  18.     //演示 return 的使用
  19.     var n int = 30
  20.     fmt.Println("ok1")
  22.     if n > 20 {
  23.         return
  24.     }
  25.     fmt.Println("ok2")
  26.     fmt.Println("ok3")
  27.     fmt.Println("ok4")
  28.     fmt.Println("ok5")
  29.     fmt.Println("ok6")
  30.     fmt.Println("ok7")
  31. }

课程来源