标签：case ... 06 标签 fmt Println 循环 Go ......
package main
import "fmt"
/* ...Go语言中的流程控制... */
/* Go语言中的流程控制结构
1. Go 语言中if条件判断的格式如下：
if 表达式1{
分支1
}else if 表达式2{
分支2
}else{
分支3
}
解析该if-else条件判断结构如下：
当表达式1的结果为true时，执行分支1，否则判断表达式2，如果满足则执行分支2，都不满足时，则执行分支3.
if判断中的else if 和 else 都是可选的，可以根据实际需要进行选择。
注意：if-else条件判断结构的左括号与if匹配的{必须于if放在同一行。同理，与else匹配的{必须与else放在同一行。
2. for循环结构
2.1 for循环结构的基本格式如下：
for 初始语句;条件表达式;结束语句{
循环体语句
}
2.2 for循环条件表达式，满足条件表达式就会不停地进行循环，直到条件表达式不满足时自动退出循环。示例如下：
for i:= 0; i < 10; i++ {
fmt.Println(i)
}
2.3 for 循环的初始语句可以被忽略，但是初始语句后的分号必须要写，例如：
i := 0
for ; i < 10; i++ {
fmt.Println(i)
}
2.4 for 循环的初始语句和结束语句都可以省略，进行一个for循环结构的变形，例如：
i := 0
for i < 10 {
fmt.Println(i)
i++
}
2.5 for 无限循环
for {
fmt.Println("没有结束条件，无限循环下去")
}
2.6 for 循环可以结合break、goto、return、panic 语句强制退出循环。每个关键字所带有的作用会有不同。
2.7 for range(键值循环)
Go语言中可以使用for range 遍历数组、切片、字符串、map、通道(channel)，通过for range遍历的返回值有以下规律：
2.7.1 数组、切片、字符串返回索引和值
2.7.2 map返回键和值
2.7.3 通道(channel) 只返回通道内的值
2.8 switch case 条件结构
2.8.1 使用switch语句可方便的对大量的值进行条件判断。Go语言规定每个switch只能有一个default分支。
2.8.2 Go 语言中每个case语句中可以不写break，不加break也不会出现穿透的现象
2.8.3 Go 语言中switch case结构中，一个case条件分支可以有多个值，多个值中间使用英文逗号分隔。
2.8.4 Go 语言中switch 的穿透 fallthrought，在满足条件的case中加上fallthrough,可以执行下一个case语句，
是为了兼容C语言中的case设计的。示例：
st := "a"
switch {
case st == "a":
fmt.Println("a")
fallthrough // 这个fallthrough 默认只能穿透一层
case st == "b":
fmt.Println("b") // 上面case加了fallthrough,这个case结构也会强制被执行。
case st == "c":
fmt.Println("c")
default:
fmt.Println("......")
}
最终打印结果是：a 和 b
2.9 break 跳出循环
2.9.1 用于循环语句中跳出循环，并开始执行循环之后的语句。
2.9.2 break在switch case结构中起到跳出当前case的作用。
2.9.3 在多重循环中，可以用标号label标出想break的循环。
extname := ".js"
switch extname {
case ".html":
fmt.Println("text/html")
break
case ".css":
fmt.Println("text/css")
break
case ".js":
fmt.Println("text/javascript") // 这个条件满足，它会打印
break
default:
fmt.Println("格式错误")
break
}
2.9.4 for循环中默认break只能跳出一层循环
for i := 0; i < 3; i++ {
if i == 2 {
break
}
fmt.Println("打印 i 的值：", i)
}
// 这个结果是：
打印 i 的值： 0
打印 i 的值： 1
2.9.5 Go语言中，在多重循环中，可以用标号label标出想break的循环。
label2: // 这个在函数中的格式是顶格写
for i := 0; i < 2; i++ {
for j := 0; j < 10; j++ {
if j == 2 {
break label2
}
fmt.Println(" i j 的值", i, "_", j)
}
}
// 这个结果是：
i j 的值 0 _ 0
i j 的值 0 _ 1
2.9.6 Go语言中 continue 是继续下一次循环，
continue 语句可以结束当前循环，开始下一次的循环迭代过程，仅限使用在for循环结构中。
for m := 0; m < 2; m++ {
for n := 0; n < 4; n++ {
if n == 1 {
continue // 当 n 的值为1时，跳过本次循环，继续执行下一次循环
}
fmt.Println(" m n 的值", m, "_", n)
}
}
// 这个结果是：
m n 的值 0 _ 0
m n 的值 0 _ 2
m n 的值 0 _ 3
m n 的值 1 _ 0
m n 的值 1 _ 2
m n 的值 1 _ 3
2.9.7 在continue关键字后添加标签时，表示开始标签对应的循环。例如：
suibian:
for x := 0; x < 2; x++ {
for y := 0; y < 4; y++ {
if y == 2 {
continue suibian
}
fmt.Println(" x y 的值", x, "_", y)
}
}
// 这个结果是：
x y 的值 0 _ 0
x y 的值 0 _ 1
x y 的值 1 _ 0
x y 的值 1 _ 1
2.9.8 goto 跳转到指定标签
goto 语句通过标签进行代码间的无条件跳转。goto 语句可以在快速跳出循环、避免重复退出上有一定的帮助。
Go 语言中使用goto 语句能简化一些代码的实现过程。
var n3 int = 30
fmt.Println("...OK1......OK1...")
if n3 > 20 {
goto label33 // 跳转到标签”label33“
}
fmt.Println("...OK2......OK2...")
fmt.Println("...OK3......OK3...")
fmt.Println("...OK4......OK4...")
label33:
fmt.Println("...OK5......OK5...")
fmt.Println("...OK6......OK6...")
fmt.Println("...OK7......OK7...")
// 这个结果是：
...OK1......OK1...
...OK5......OK5...
...OK6......OK6...
...OK7......OK7...
2.9.9 使用goto语句能简化代码
for x := 0; x < 2; x++ {
for y := 0; y < 4; y++ {
if y == 2 {
// 设置退出标签 breakTag
goto breakTag
}
fmt.Println(" 最新 x y 的值", x, "_", y)
}
}
// 退出标签
breakTag:
fmt.Println(" 结束for循环 ")
fmt.Println()
// 这个结果是：
最新 x y 的值 0 _ 0
最新 x y 的值 0 _ 1
结束for循环
*/
func main() {
// 1. if 条件判断特殊写法
// 可以再if表达式之前添加一个执行语句，再根据变量值进行判断，例子如下：
// 知识点：这个if-else结构中的score变量属于局部作用域。离开if-else结构体去使用会直接报错。
if score := 56; score >= 90 {
fmt.Println("AAA")
} else if score > 75 {
fmt.Println("BBB")
} else {
fmt.Println("CCC") // 条件满足，会被执行
}
// 练习1：求两个数的最大值
var n1 int = 20
var n2 int = 55
var max int
if n1 > n2 {
max = n1
} else {
max = n2
}
fmt.Println("max=", max) // max= 55
// 练习2：判断一个人的成绩，小于60分不及格，大于等于60小于80及格，大于80优秀
if score := 39; score < 60 {
fmt.Println("不及格") // 条件满足，会被执行
} else if score >= 60 && score < 80 {
fmt.Println("及格")
} else {
fmt.Println("优秀")
}
// 练习3：不满足条件时，使用 break 结束循环
k := 1
for {
if k <= 3 {
fmt.Println("ok~~~", k)
} else {
break
}
k++
}
// 练习4：打印0-10所有的偶数
for i := 0; i < 10; i++ {
if i%2 == 0 {
fmt.Println("0-10之间的偶数", i)
}
}
// 练习5：1-100 之间所有是9的倍数的数字，求出并打印，这些整数的个数以及他们的总和
count := 0
sum := 0
for i := 1; i < 100; i++ {
if i%9 == 0 {
sum += i
count++
}
}
fmt.Println("个数count=", count, "总和sum=", sum) // 个数count= 11 总和sum= 594
// 练习6： 求1+2+3+4+...+100 的和
sum100 := 0
for i := 1; i <= 100; i++ {
sum100 += i
}
fmt.Println("sum100=", sum100) // sum100= 5050
// 练习7： 计算5的阶乘
var n = 5
sumj := 1
for i := 1; i <= n; i++ {
sumj *= i
}
fmt.Println("sumj=", sumj) // sumj= 120
// 练习8： 打印一个矩形
for i := 1; i <= 12; i++ {
fmt.Print("*")
if i%4 == 0 {
fmt.Println()
}
}
// 练习8：打印一个四行八列的矩形
line := 4
num := 8
for i := 1; i <= line; i++ {
for j := 0; j < num; j++ {
fmt.Print("*")
}
fmt.Println()
}
// 练习9：打印一个三角形
line2 := 5
for i := 1; i <= line2; i++ {
for j := 1; j <= i; j++ {
fmt.Print("*")
}
fmt.Println()
}
// 练习10：打印出99乘法表
for i := 1; i <= 9; i++ {
for j := 1; j <= i; j++ {
fmt.Printf("%dx%d=%d\t", i, j, i*j) // \t就是一个Tab键的距离。
}
fmt.Println()
}
/* 2. for range(键值循环)
Go 语言中可以使用for range 遍历数组、切片、字符串、map 及通道(channel)。通过for range遍历的返回值有以下规律：
2.1 数组、切片、字符串返回索引和值。
2.2 map 返回键和值。
2.3 通道(channel)只返回通道内的值。
*/
str := "abc 上海"
for index, value := range str {
fmt.Printf("index=%d, value=%c \n", index, value)
}
str2 := "abc 上海"
for _, value := range str2 {
fmt.Printf("value=%c \n", value)
}
/* 3. switch case条件判断
使用switch语句可方便的对大量的值进行条件判断。
Go语言规定每个switch只能有一个default分支。
*/
// 练习：判断文件类型，如果后缀名是.html 输出text/html,如果后缀名是.css 输出text/css,如果后缀名是.js 输出text/javascript
// 3.1 Go 语言规定每个switch只能有一个default分支。
extname := ".js"
switch extname {
case ".html":
fmt.Println("text/html")
break
case ".css":
fmt.Println("text/css")
break
case ".js":
fmt.Println("text/javascript")
break
default:
fmt.Println("格式错误") // 这个条件满足，它会打印
break
}
// 3.2 Go 语言中每个case语句中可以不写break，不加break也不会出现穿透的现象，如下例子：
extname2 := ".a"
switch extname2 {
case ".html":
fmt.Println("text/html")
case ".css":
fmt.Println("text/css")
case ".js":
fmt.Println("text/javascript")
default:
fmt.Println("格式错误") // 这个条件满足，它会打印
}
// 3.3 Go 语言中switch case结构中，一个case条件分支可以有多个值，多个值中间使用英文逗号分隔。
nn := 2
switch nn {
case 1, 3, 5, 7, 9:
fmt.Println("我是奇数")
case 2, 4, 6, 8:
fmt.Println("我是偶数") // 这个条件满足，它会打印
default:
fmt.Println(nn)
}
// 3.3.1 Go 语言中switch case结构的另一种写法：
switch n := 7; n {
case 1, 3, 5, 7, 9:
fmt.Println("奇数")
case 2, 4, 6, 8:
fmt.Println("偶数")
default:
fmt.Println(n)
}
// 3.3.2 Go 语言中switch case结构的另一种写法：
// switch case 分支还可以使用表达式，这时候switch语句后面不需要再跟判断变量。
age := 56
switch {
case age < 25:
fmt.Println("好好学习吧")
case age > 25 && age <= 60:
fmt.Println("好好工作吧")
case age > 60:
fmt.Println("好好享受吧")
case age > 70 && age <= 85:
fmt.Println("每天锻炼一小会")
default:
fmt.Println("活着真好！")
}
// 3.3.3 switch 的穿透 fallthrought
// 在满足条件的case中加上fallthrough,可以执行下一个case语句，是为了兼容C语言中的case设计的。
st := "a"
switch {
case st == "a":
fmt.Println("a")
fallthrough // 这个fallthrough 默认只能穿透一层
case st == "b":
fmt.Println("b") // 上面case加了fallthrough,这个case结构也会强制被执行。
case st == "c":
fmt.Println("c")
default:
fmt.Println("......")
}
// 3.3.4 switch 的穿透 fallthrough ,默认只能穿透一层，根据这个特性，写一个例子
var num2 int = 10
switch num2 {
case 10:
fmt.Println("OK1") // 这个会被执行
fallthrough
case 20:
fmt.Println("OK2") // 这个也会被执行
fallthrough
case 30:
fmt.Println("OK3") // 这个也会被执行
default:
fmt.Println("...没有匹配到...")
}
// 4. for循环中默认break 只能跳出一层循环
for i := 0; i < 3; i++ {
if i == 2 {
break
}
fmt.Println("打印 i 的值：", i)
}
// 4.1 通过break结束for循环
kk := 1
for {
if kk <= 10 {
fmt.Println("OK~~~", kk)
} else {
break // 当kk=11时，条件不满足就会跳出这个for循环
}
kk++
}
// 4.2 在多重循环中，可以用标号label标出想break的循环。
label2:
for i := 0; i < 2; i++ {
for j := 0; j < 10; j++ {
if j == 2 {
break label2
}
fmt.Println(" i j 的值", i, "_", j)
}
}
fmt.Println()
// 4.3 continue 语句可以结束当前循环，继续下一次循环，仅限使用在for循环结构中。
for m := 0; m < 2; m++ {
for n := 0; n < 4; n++ {
if n == 1 {
continue
}
fmt.Println(" m n 的值", m, "_", n)
}
}
fmt.Println()
// 4.4 在continue关键字后添加标签时，表示开始标签对应的循环。例如：
suibian:
for x := 0; x < 2; x++ {
for y := 0; y < 4; y++ {
if y == 2 {
continue suibian
}
fmt.Println(" x y 的值", x, "_", y)
}
}
fmt.Println()
// 4.5 goto跳转到指定标签
/* 4.5 goto跳转到指定标签
goto 语句通过标签进行代码间的无条件跳转。goto语句可以在快速跳出循环、避免重复退出上有一定的帮助。
Go 语言中使用goto语句能简化一些代码的实现过程。
*/
var n3 int = 30
fmt.Println("...OK1......OK1...")
if n3 > 20 {
goto label33 // 跳转到标签”label33“
}
fmt.Println("...OK2......OK2...")
fmt.Println("...OK3......OK3...")
fmt.Println("...OK4......OK4...")
label33:
fmt.Println("...OK5......OK5...")
fmt.Println("...OK6......OK6...")
fmt.Println("...OK7......OK7...")
fmt.Println()
// 4.6 使用 goto 能简化代码
for x := 0; x < 2; x++ {
for y := 0; y < 4; y++ {
if y == 2 {
// 设置退出标签
goto breakTag
}
fmt.Println(" 最新 x y 的值", x, "_", y)
}
}
// 退出标签
breakTag:
fmt.Println(" 结束for循环 ")
fmt.Println()
// ***********end*************
/* 上面所有代码执行的结果如下：
PS C:\Users\Zhaoshan.lu\go\DaDi> go run .\08.go
CCC
max= 55
不及格
ok~~~ 1
ok~~~ 2
ok~~~ 3
0-10之间的偶数 0
0-10之间的偶数 2
0-10之间的偶数 4
0-10之间的偶数 6
0-10之间的偶数 8
个数count= 11 总和sum= 594
sum100= 5050
sumj= 120
****
****
****
********
********
********
********
*
**
***
****
*****
1x1=1
2x1=2 2x2=4
3x1=3 3x2=6 3x3=9
4x1=4 4x2=8 4x3=12 4x4=16
5x1=5 5x2=10 5x3=15 5x4=20 5x5=25
6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36
7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49
8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64
9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81
index=0, value=a
index=1, value=b
index=2, value=c
index=3, value=
index=4, value=上
index=7, value=海
value=a
value=b
value=c
value=
value=上
value=海
text/javascript
格式错误
我是偶数
奇数
好好工作吧
a
b
OK1
OK2
OK3
打印 i 的值： 0
打印 i 的值： 1
OK~~~ 1
OK~~~ 2
OK~~~ 3
OK~~~ 4
OK~~~ 5
OK~~~ 6
OK~~~ 7
OK~~~ 8
OK~~~ 9
OK~~~ 10
x y 的值 0 _ 0
x y 的值 0 _ 1
x y 的值 1 _ 0
x y 的值 1 _ 1
...OK1......OK1...
...OK5......OK5...
...OK6......OK6...
...OK7......OK7...
最新 x y 的值 0 _ 0
最新 x y 的值 0 _ 1
结束for循环
PS C:\Users\Zhaoshan.lu\go\DaDi>
*/
}
标签：case,
...,
06,
标签,
fmt,
Println,
循环,
Go,
......
From： https://www.cnblogs.com/ludundun/p/16941825.html