Go语言学习笔记—golang流程控制

PPPsych

463人浏览 · 2022-06-18 18:39:25

PPPsych · 2022-06-18 18:39:25 发布

视频来源：B站《golang入门到项目实战 [2022最新Go语言教程，没有废话，纯干货！]》

文章为自己整理的学习笔记，侵权即删，谢谢支持！

文章目录

一 Go语言中的流程控制简介

Go语言中的条件：

if 语句：if 语句由一个布尔表达式后紧跟一个或多个语句组成。
if…else 语句: if 语句后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。
if 嵌套语句: 你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。
switch 语句: switch 语句用于基于不同条件执行不同动作。
select 语句: select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。

Go语言中的循环语句：

for循环
for range循环

go语言中的循环只有for循环，去除了while、do while循环，使用起来更加简洁。

Go语言中的流程控制关键字：

break
continue
goto

二 Go语言中的if语句

go语言中的if语句和其他语言中的类似，都是根据给定的条件表达式运算结果来，判断执行流程。

2.1 语法

if 布尔表达式 {	
    // 代码块
}

注意：在go语言中布尔表达式不用使用括号。

2.2 实例演示

① 基础演示

package main

import (
	"fmt"
)

func main() {
	a := 1
	b := 2
	if a < b {
		fmt.Printf("a: %v\n", a)
	} 
}

运行结果：

a: 1

② 根据年龄判断是否成年

package main

import (
	"fmt"
)

func main() {
	age := 20
	if age > 18 {
		fmt.Println("成年")
	} 
	fmt.Printf("程序运行结束")
}

运行结果：

成年
程序运行结束

注：初始变量可以声明在布尔表达式里面，注意它的作用域（只能作用域if语句内，在if语句外引用则报错）

package main

import (
	"fmt"
)

func main() {
	if age := 20; age > 18 { // 将初始变量age放到表达式里
		fmt.Println("成年")
	} 
	fmt.Printf("程序运行结束")
}

2.3 注意事项

不需使用括号将条件包含起来
大括号{}必须存在，即使只有一行语句
左括号必须在if或else的同一行
在if之后，条件语句之前，可以添加变量初始化语句，使用;进行分隔
在if语句表达式中不能使用0或非0表示真假

package main

import (
	"fmt"
)

func main() {
	var i = 1
	if i {		// 此处编译报错
		fmt.Println("真")
	}
	fmt.Printf("程序运行结束")
}

三 Go语言中的if else语句

go语言中的if else语句可以根据给定条件二选一。

3.1 语法

if 布尔表达式 {
   // 代码块1
} else {
   // 代码块2
}

强调一下：双分支只会执行其中的一个分支。

3.2 实例演示

① 比较两个数的大小

package main

import (
	"fmt"
)

func main() {
	a := 1
	b := 2
	if a > b {
		fmt.Printf("\"a>b\": %v\n", "a>b")
	} else {
		fmt.Printf("\"a<=b\": %v\n", "a<b")
	}
	fmt.Println("程序运行结束")
}

运行结果：

"a<=b": a<b
程序运行结束

② 判断一个数是奇数还是偶数

package main

import (
	"fmt"
)

func main() {
	var num int
	fmt.Println("输入一个整数num：")
    fmt.Scan(&num)	// ftm.Scan()用于接收用户在终端输入的值

	if num%2 == 0 {
		fmt.Print("num 是偶数\n")
	} else {
		fmt.Print("num 是奇数\n")
	}
	fmt.Print("num 的值是：", num)

}

运行结果：

输入一个整数num：
7
num 是奇数
num 的值是：7

③ 判断一个人是否成年

package main

import (
	"fmt"
)

func main() {
	var age int
	fmt.Println("输入你的年龄：")
	fmt.Scan(&age)

	if age >= 18 {
		fmt.Println("你是成年人")
	} else {
		fmt.Println("你是未成年")
	}

}

运行结果：

输入你的年龄：
18
你是成年人

3.3 注意事项（同if语句）

不需使用括号将条件包含起来
大括号{}必须存在，即使只有一行语句
左括号必须在if或else的同一行
在if之后，条件语句之前，可以添加变量初始化语句，使用;进行分隔
在if语句表达式中不能使用0或非0表示真假

四 Go语言中的if else if语句

go语言if语句可以进行多重嵌套使用，进行多重判断。

4.1 语法

if 布尔表达式1 {
    
    // 代码块1
    
} else if 布尔表达式2 {
    
    // 代码块2
    
}
...
else {
    
    // 代码块n
    
}

判断流程如下:

先判断条件表达式 1 是否成立，如果为真，就执行代码块 1
如果条件表达式 1 如果为假，就去判断条件表达式 2 是否成立，如果条件表达式 2 为真，就执行代码块 2
依次类推.
如果所有的条件表达式不成立，则执行 else 的语句块。
- else 不是必须的。
- 多分支只能有一个执行入口。

4.2 实例演示

① 根据分数判断等级

package main

import (
	"fmt"
)

func main() {
	var score int
	fmt.Println("输入你的成绩：")
	fmt.Scan(&score)

	if score < 60 {
		fmt.Println("你的成绩为D")
	} else if score >= 60 && score <= 70 {
		fmt.Println("你的成绩为C")
	} else if score > 70 && score <= 90 {
		fmt.Println("你的成绩为B")
	} else {
		fmt.Println("你的成绩为A")
	}

}

运行结果：

输入你的成绩：
92
你的成绩为A

② 输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续判断第二个字母

package main

import (
	"fmt"
)

func main() {
	//  Monday Tuesday Wednesday Thursday Friday Saturday Sunday
	var c string
	fmt.Println("输入第一个字母：")
	fmt.Scan(&c)

	if c == "S" {
		fmt.Println("输入第二个字母：")
		fmt.Scan(&c)
		if c == "a" {
			fmt.Println("Saturday")
		} else if c == "u" {
			fmt.Println("Sunday")
		} else {
			fmt.Println("输入错误")
		}
	} else if c == "F" {
		fmt.Println("Friday")
	} else if c == "M" {
		fmt.Println("Monday")
	} else if c == "T" {
		fmt.Println("输入第二个字母：")
		fmt.Scan(&c)
		if c == "u" {
			fmt.Println("Tuesday")
		} else if c == "h" {
			fmt.Println("Thursday")
		} else {
			fmt.Println("输入错误")
		}
	} else if c == "W" {
		fmt.Println("Wednesday")
	} else {
		fmt.Println("输入错误")
	}

}

运行结果：

输入第一个字母：
S
输入第二个字母：
a
Saturday

五 Go语言中的嵌套if语句

go语言if语句可以嵌套多级进行判断。

5.1 语法

if 布尔表达式 1 {
    
   // 代码块1
   
   if 布尔表达式 2 {
      
       // 代码块2
       
   }
}

建议嵌套控制在三层内

5.2 实例演示

① 判断三个数的大小

package main
 
import "fmt"
 
// a>b a>c a
// b>a b>c b else c
 
func f1() {	// 创建一个判断大小的函数
    a := 100
    b := 200
    c := 3
    if a > b {
        if a > c {
            fmt.Println("a最大")
        }
    } else {
        if b > c {
            fmt.Println("b最大")
        } else {
            fmt.Println("c最大")
        }
    }
}
 
func main() {
    f1()	// 调用上面判断大小的函数
}

运行结果：

b最大

② 判断男生还是女生，并且是否成年

package main

import "fmt"

func f2() {
	// 判断男女生及年龄
	gender := "女生"
	age := 16
	if gender == "男生" {
		if age > 18 {
			fmt.Println("成年男性")
		} else {
			fmt.Println("未成年男孩")
		}
	} else {
		if age > 18 {
			fmt.Println("成年女性")
		} else {
			fmt.Println("未成年女孩")
		}
	}
}

func main() {
	f2()
}

运行结果：

未成年女孩

六 Go语言中的switch语句

go语言中的switch语句，可以非常容易的判断多个值的情况。

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

6.1 语法

switch 表达式 {
    case 表达式1:
    	  
    	  // 代码块1
    
    case 表达式2:
    
    	  // 代码块2
    
    ...
    
    default:
    
		  // 代码块n	
    
}

switch 的执行的流程是，先执行表达式，得到值，然后和 case 的表达式进行比较，如果相等，就匹配到，然后执行对应的 case 的语句块，然后退出 switch 控制。
如果 switch 的表达式的值没有和任何的 case 的表达式匹配成功，则执行 default 的语句块。执行后退出 switch 的控制.
golang 的 case 后的表达式可以有多个，使用逗号 , 间隔.
golang 中的 case 语句块不需要写 break , 因为默认会有,即在默认情况下，当程序执行完 case 语句块后，就直接退出该 switch 控制结构。

6.2 实例演示

6.2.1 常规使用

判断成绩：

package main
 
import (
    "fmt"
)
 
func f() {
    grade := "A"
    switch grade {
    case "A":
        fmt.Println("优秀")
    case "B":
        fmt.Println("良好")
    default:
        fmt.Println("一般")
    }
}
 
func main() {
    f()
}

运行结果：

优秀

6.2.2 多条件匹配

go语言switch语句，可以同时匹配多个条件，中间用逗号,分隔，有其中一个匹配成功即可。

package main
 
import (
    "fmt"
)
 
func f() {
    day := 3
    switch day {
    case 1, 2, 3, 4, 5:
        fmt.Println("工作日")
    case 6, 7:
        fmt.Println("休息日")
    }
}
 
func main() {
    f()
}

运行结果：

工作日

6.2.3 `case`可以是条件表达式

package main
 
import (
    "fmt"
)
 
func f() {
    score := 90
    switch {
    case score >= 90:
        fmt.Println("享受假期")
    case score < 90 && score >= 80:
        fmt.Println("好好学习吧！")
    default:
        fmt.Println("玩命学习！")
    }
}
 
func main() {
    f()
}

运行结果：

享受假期

6.2.4 `fallthrough`可以执行满足条件的下一个`case`

默认只穿透一层

package main
 
import (
    "fmt"
)
 
func f3() {
    a := 100
    switch a {
    case 100:
        fmt.Println("100")
        fallthrough	// 向下穿透，可执行下一个case
    case 200:
        fmt.Println("200")
    case 300:
        fmt.Println("300")
    default:
        fmt.Println("other")
    }
}
 
func main() {
    f3()
}

运行结果：

100
200

6.2.5 `Type Switch`（先了解）

switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际指向的变量类型

package main

import (
	"fmt"
)

func f() {
	var x interface{}
	var y = 10.0
	x = y
	switch i := x.(type) {
	case nil:
		fmt.Printf("x的类型是: %T", i)
	case int:
		fmt.Printf("x是int型")
	case float64:
		fmt.Printf("x是float64型")
	case func(int) float64:
		fmt.Printf("x是func(int)型")
	case bool, string:
		fmt.Printf("x是bool型 或 string型")
	default:
		fmt.Printf("未知型")
	}
}

func main() {
	f()
}

运行结果：

x是float64型

6.3 注意事项

case/switch 后是一个表达式( 即：常量值、变量、一个有返回值的函数等都可以)
case 后的各个表达式的值的数据类型，必须和 switch 的表达式数据类型一致
支持多条件匹配，case 后面可以带多个表达式，使用逗号 , 间隔。比如 case 表达式 1, 表达式 2 ...
case 后面的表达式如果是常量值(字面量)，则要求不能重复
不同的 case 之间不使用 break 分隔，默认只会执行一个 case
default 语句不是必须的
switch 后也可以不带表达式，类似 if --else 分支来使用
如果想要执行多个 case，需要使用 fallthrough 关键字，也可用 break 终止。
Type Switch：switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际指向的变量类型

6.4 switch 和 if 的比较

如果判断的具体数值不多，而且符合整数、浮点数、字符、字符串这几种类型。建议使用 swtich语句，简洁高效。
其他情况：对区间判断和结果为 bool 类型的判断，使用 if，if 的使用范围更广。

七 Go语言中的for循环语句

Go语言中的for循环，只有for关键字，去除了像其他语言中的while和do while.

7.1 语法

for 循环变量初始化; 循环条件; 循环变量迭代{
    
    循环体语句

}

注意：for表达式不用加括号

流程说明：

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

7.2 实例演示

循环输出1到10

① 常规写法

package main
 
import (
    "fmt"
)
 
func f() {
    for i := 1; i <= 10; i++ {
        fmt.Printf("i: %v\n", i)
    }
}
 
func main() {
    f()
}

运行结果：

i: 1
i: 2
i: 3
i: 4
i: 5
i: 6
i: 7
i: 8
i: 9
i: 10

② 将循环变量初始化写在外面

package main
 
import "fmt"
 
func f() {
    i := 1
    for ; i <= 10; i++ {
        fmt.Printf("i: %v\n", i)
    }
}
 
func main() {
    f()
}

③ 将循环条件和循环变量迭代省略

package main
 
import "fmt"
 
func f() {
    i := 1 // 循环变量初始化
    for i <= 10 {
        fmt.Printf("i: %v\n", i)
        i++ // 变量迭代
    }
}
 
func main() {
    f()
}

这种情况类似其他语言中的while循环

④ 永真循环

package main
 
import "fmt"
 
func f() {
    for {
        fmt.Println("我一直在执行~")
    }
}
 
func main() {
    f()
}

运行结果：

我一直在执行~
我一直在执行~
我一直在执行~
我一直在执行~
我一直在执行~
我一直在执行~
...

for循环可以通过break、goto、return、panic语句强制退出循环。

八 Go语言中的for range循环

Go语言中可以使用for range遍历数组、切片、字符串、map 及通道（channel）。

通过for range遍历的返回值有以下规律：

数组、切片、字符串返回索引和值。
map返回键和值。
通道（channel）只返回通道内的值。

① 循环数组

package main
 
import "fmt"
 
func f() {
    var a = [5]int{1, 2, 3, 4, 5}	
    // 初始化一个数组
    for i, v := range a {
        // i为索引，v为索引i对应的值
        fmt.Printf("i: %d, v: %v\n", i, v)
    }
}
 
func main() {
    f()
}

运行结果：

i: 0, v: 1
i: 1, v: 2
i: 2, v: 3
i: 3, v: 4
i: 4, v: 5

② 循环字符串

package main

import "fmt"

func f() {
	var s = "golang流程控制"
	for i, v := range s {
		fmt.Printf("i: %d, v: %c\n", i, v)
		// %c 按照字符输出
	}
}

func main() {
	f()
}

运行结果：

i: 0, v: g
i: 1, v: o
i: 2, v: l
i: 3, v: a
i: 4, v: n
i: 5, v: g
i: 6, v: 流
i: 9, v: 程
i: 12, v: 控
i: 15, v: 制

③ 循环切片

package main
 
import "fmt"
 
func f() {
    var s = []int{1, 2, 3, 4, 5}
    // 初始化一个切片
    for i, v := range s {
        // i为索引，v为索引i对应的值
        fmt.Printf("i: %d, v: %v\n", i, v)
    }
}
 
func main() {
    f()
}

运行结果：

i: 0, v: 1
i: 1, v: 2
i: 2, v: 3
i: 3, v: 4
i: 4, v: 5

④ 循环map

package main

import "fmt"

func f() {
	m := make(map[string]string)
	m["name"] = "psych"
	m["age"] = "18"
	m["email"] = "psych@email.com"
	// 初始化一个map
	for k, v := range m {
		// k为键，v为键对应的值
		fmt.Printf("k: %v, v: %v\n", k, v)
	}
}

func main() {
	f()
}

运行结果：

k: age, v: 18
k: email, v: psych@email.com
k: name, v: psych

九 Go语言流程控制关键字break

break语句可以结束for、switch和select的代码块。

9.1 使用break的注意事项

单独在select中使用break和不使用break没有啥区别。
单独在表达式switch语句，并且没有fallthough，使用break和不使用break没有啥区别。
单独在表达式switch语句，并且有fallthough，使用break能够终止fallthough后面的case语句的执行。
带标签的break，可以跳出多层select/ switch作用域。让break更加灵活，写法更加简单灵活，不需要使用控制变量一层一层跳出循环，没有带break的只能跳出当前语句块。

9.2 实例演示

① 跳出for循环

package main
 
import "fmt"
 
func f() {
    for i := 0; i < 10; i++ {
        if i == 5 {
            break // 退出循环
        }
        fmt.Printf("i: %v\n", i)
    }
}
 
func main() {
    f()
}

运行结果：

i: 0
i: 1
i: 2
i: 3
i: 4

② 跳出switch语句

package main
 
import "fmt"
 
func f() {
    i := 2
    switch i {
    case 1:
        fmt.Println("等于1")
        break
    case 2:
        fmt.Println("等于2")
        break	// 若此处没有break，则将向下穿透继续执行case3
        fallthrough
    case 3:
        fmt.Println("等于3")
        break
    default:
        fmt.Println("错误")
        break
    }
}
 
func main() {
    f()
}

运行结果：

等于2

③ 跳转到标签处

package main
 
import "fmt"
 
func f() {
MY_LABEL:	// 生成一个标签
    for i := 0; i < 10; i++ {
        if i == 5 {
            break MY_LABEL	// 跳转到标签处继续执行代码
        }
        fmt.Printf("%v\n", i)
    }
    fmt.Println("end...")
}
func main() {
    f()
}

运行结果：

0
1
2
3
4
end...

十 Go语言关键字continue

continue只能用在循环中，在Go中只能用在for循环中，它可以终止本次循环，进行下一次循环。
在 continue语句后添加标签时，表示开始标签对应的循环。

① 输出1到10之间的偶数

package main

import "fmt"

func f() {
	for i := 0; i < 10; i++ {
		if i%2 == 0 {
			fmt.Printf("i: %v\n", i)
		} else {
			fmt.Println("继续执行")
			continue
		}
	}
}
func main() {
	f()
}

运行结果：

i: 0
继续执行
i: 2
继续执行
i: 4
继续执行
i: 6
继续执行
i: 8
继续执行

② 跳转到标签

package main
 
import "fmt"
 
func f() {
    for i := 0; i < 3; i++ {
    MY_LABEL:
        for j := 0; j < 3; j++ {
            if i == 2 && j == 2 {
                continue MY_LABEL
                // 当i=2并且j=2时跳转到标签，即输出结果不存在i=2，j=2
            	 	
            }
            fmt.Printf("i=%d,j=%d\n", i, j)
        }
    }
}
func main() {
    f()
}

运行结果：

i=0,j=0
i=0,j=1
i=0,j=2
i=1,j=0
i=1,j=1
i=1,j=2
i=2,j=0
i=2,j=1

十一 Go语言流程控制关键字goto

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

① 跳转到指定标签

package main

import "fmt"

func f() {
	a := 0
	if a == 1 {
		fmt.Println("other")
	} else {
		goto LABEL1
	}

LABEL1:
	fmt.Printf("next...")
}
func main() {
	f()
}

运行结果：

next...

② 跳出双层嵌套循环

package main

import "fmt"

func f() {
	for i := 0; i < 5; i++ {
		for j := 0; j < 5; j++ {
			if i >= 2 && j >= 2 {
				goto LABEL1
			}
			fmt.Printf("i: %v, j:%v\n", i, j)
		}
	}
LABEL1:
	fmt.Println("END...")
}

func main() {
	f()
}

运行结果：

i: 0, j:0
i: 0, j:1
i: 0, j:2
i: 0, j:3
i: 0, j:4
i: 1, j:0
i: 1, j:1
i: 1, j:2
i: 1, j:3
i: 1, j:4
i: 2, j:0
i: 2, j:1
END...

练习

1、 Go 语言没有 while 语法，但可以通过 for 循环来实现其使用效果

在这里插入图片描述

例如：输出 10 句”hello,wrold”

package main

import (
	"fmt"
)

func main() {
	i := 1
	for {
		if i > 10 {
			break
		}
		fmt.Println("hello,world", i)
		i++
	}
	fmt.Println("i=", i)
}

运行结果：

hello,world 1
hello,world 2
hello,world 3
hello,world 4
hello,world 5
hello,world 6
hello,world 7
hello,world 8
hello,world 9
hello,world 10
i= 11

2、 Go 语言没有 do while 语法，但可以通过 for 循环来实现其使用效果**

在这里插入图片描述

例如：输出 10 句”hello,wrold”

package main

import (
	"fmt"
)

func main() {
	i := 1
	for {
		fmt.Println("hello,world", i)
		i++
		if i > 10 {
			break
		}
	}
}

运行结果：

hello,world 1
hello,world 2
hello,world 3
hello,world 4
hello,world 5
hello,world 6
hello,world 7
hello,world 8
hello,world 9
hello,world 10

3、打印九九乘法表

package main

import (
	"fmt"
)

func main() {
	num := 9
	for i := 1; i <= num; i++ {
		for j := 1; j <= i; j++ {
			fmt.Printf("%v * %v = %v \t", j, i, j*i)
		}
	}
}

4、实现登录验证，有三次机会，如果用户名为”张无忌” ,密码”888”提示登录成功，否则提示还有几次机会

package main

import (
	"fmt"
)

func f() {
	var name string
	var pwd string
	var LoginChance = 3
	for i := 1; i <= 3; i++ {
		fmt.Println("请输入用户名：")
		fmt.Scanln(&name)
		fmt.Println("请输入密码：")
		fmt.Scanln(&pwd)

		if name == "psych" && pwd == "666" {
			fmt.Println("登陆成功！")
			break
		} else {
			LoginChance--
			fmt.Printf("你还有%v次登陆机会\n", LoginChance)
		}

	}

	if LoginChance == 0 {
		fmt.Println("登录次数已用完")
	}
}

func main() {
	f()
}

运行结果：

请输入用户名：
sss
请输入密码：
sss
你还有2次登陆机会
请输入用户名：
psych
请输入密码：
sss
你还有1次登陆机会
请输入用户名：
psych
请输入密码：
111 
你还有0次登陆机会
登录次数已用完

请输入用户名：
psych
请输入密码：
666
登陆成功！

5、从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为 0 时结束程序

package main

import (
	"fmt"
)

func f() {
	var positiveCount int	// 正数的个数
	var negativeCount int	// 负数的个数
	var num int

	for {
		fmt.Println("请输入一个整数：")
		fmt.Scanln(&num)

		if num == 0 {
			break
		}

		if num > 0 {
			positiveCount++
			continue
		}
		negativeCount++
	}
	fmt.Printf("整数个数是%v，负数个数是%v", positiveCount, negativeCount)
}

func main() {
	f()
}

运行结果：

请输入一个整数：
1
请输入一个整数：
-3
请输入一个整数：
2
请输入一个整数：
6
请输入一个整数：
-2
请输入一个整数：
7
请输入一个整数：
0
整数个数是4，负数个数是2

乐奇 Rokid 开放社区

更多推荐

AR巡检哪家好，和浪潮比哪家方案更成熟

乐奇 Rokid 开放社区

AR巡检哪家好

乐奇 Rokid 开放社区

瑞丰宝丽在AR巡检领域排名

乐奇 Rokid 开放社区

所有评论(0)

查看更多评论

PPPsych

@qq_39280718

已为社区贡献11条内容

Go语言学习笔记—golang流程控制

PPPsych

文章目录

一 Go语言中的流程控制简介

二 Go语言中的if语句

2.1 语法

2.2 实例演示

2.3 注意事项

三 Go语言中的if else语句

3.1 语法

3.2 实例演示

3.3 注意事项（同if语句）

四 Go语言中的if else if语句

4.1 语法

4.2 实例演示

五 Go语言中的嵌套if语句

5.1 语法

5.2 实例演示

六 Go语言中的switch语句

6.1 语法

6.2 实例演示

6.2.1 常规使用

6.2.2 多条件匹配

6.2.3 case可以是条件表达式

6.2.4 fallthrough可以执行满足条件的下一个case

6.2.5 Type Switch（先了解）

6.3 注意事项

6.4 switch 和 if 的比较

七 Go语言中的for循环语句

7.1 语法

7.2 实例演示

八 Go语言中的for range循环

九 Go语言流程控制关键字break

9.1 使用break的注意事项

9.2 实例演示

十 Go语言关键字continue

十一 Go语言流程控制关键字goto

练习

所有评论(0)

温馨提示：您尚未绑定手机号

PPPsych

6.2.3 `case`可以是条件表达式

6.2.4 `fallthrough`可以执行满足条件的下一个`case`

6.2.5 `Type Switch`（先了解）