go基础之流程控制（下）
程序流程控制介绍
在程序中，程序流程控制决定程序是如何执行的，是我们必须掌握的主要有三大流程控制语句
1）顺序控制
2）分支控制
3）循环控制
顺序执行介绍
程序从上到下逐行执行，中间没有任何判断和跳转
分支控制if-else 介绍
让程序有选择的执行，分支控制有三种
1）单分支
2）双分支
3）多分支
单分支基本语法
if 条件表达式{
执行代码块
}
说明当条件表达式为true 时，就会执行{}的代码；注意{}是必须有的，就算只有一行
示例
package main
import (
"fmt"
)
func main(){
var age byte
fmt.Println("请输入年龄")
fmt.Scanln(&age)
if age > 18{
fmt.Println("你年龄太大")
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo01\main.go
// 请输入年龄
// 17
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo01\main.go
// 请输入年龄
// 20
// 你年龄太大
单分支流程图
单分支
go 的if 还有一个强大的地方就是条件判断语句里允许声明一个变量，这个变量的作用域只能在该条件逻辑块内，其他地方不起作用
示例
package main
import (
"fmt"
)
func main(){
// var age byte
// fmt.Println("请输入年龄")
// fmt.Scanln(&age)
if age:=20; age > 18{
fmt.Println("你年龄太大")
}
}
// 执行结果
// 你年龄太大
双分支
基础语法
if条件表达式{
代码块1
}else{
代码块2
}
说明：当条件表达式成立，即执行代码块1，否则执行代码块2.{}也是必须得
示例
package main
import (
"fmt"
)
func main(){
var age byte
fmt.Println("请输入年龄")
fmt.Scanln(&age)
if age > 18{
fmt.Println("你年龄太大")
} else {
fmt.Println("你该上学了")
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo02\main.go
// 请输入年龄
// 21
// 你年龄太大
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo02\main.go
// 请输入年龄
// 13
// 你该上学了
双分支流程图
测试题
package main
import (
"fmt"
)
func main(){
var t1 int32 = 32
var t2 int32 = 23
var t3 int32
t3 = t1+t2
if t3 >= 50{
fmt.Println("hello world")
}
var f1 float32 = 8.5
var f2 float32 = 12.6
f3 := f1+f2
if f3 > 10.0 {
if f2 < 20 {
fmt.Println("两数的和",f3)
}
}
var c1 int32 = 65
var c2 int32 = 25
c3 := c1+c2
if c4 := c3%3 ; c4 == 0 {
if c5:=c3%5; c5 == 0 {
fmt.Println("成~~~")
}
}
var s int = 2026
if t := s%400; t==0{
fmt.Println(s,"是闰年")
}else{
fmt.Println(s,"不是闰年")
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo03\main.go
// hello world
// 两数的和 21.1
// 成~~~
// 2026 不是闰年
示例2
package main
import (
"fmt"
)
func main(){
var t1 int32 = 32
var t2 int32 = 23
if ( t1 + t2 ) >= 50{
fmt.Println("hello world")
}
var f1 float32 = 10.5
var f2 float32 = 8.6
if f1 > 10.0 && f2 <20 {
fmt.Println("和=",(f1+f2))
}
var c1 int32 = 65
var c2 int32 = 25
if ( c1 + c2 ) % 3 == 0 && (c1 + c2) % 5 == 0{
fmt.Println((c1+c2),"能被整除")
}
var s int = 2026
if (s %4 ==0 &&s % 100 !=0) || s % 400 == 0 {
fmt.Println(s,"是闰年")
} else {
fmt.Println(s,"不是闰年")
}
}
// 执行结果
// hello world
// 和= 19.1
// 90 能被整除
// 2026 不是闰年
多分支
基本语法
if条件表达式1{
执行代码块1
}else if 条件表达式{
执行代码块2
}
...
else{
执行代码块n
}
对上面
（1）多分支的判断条件表达式1是否成立，如果为真，就执行代码块1
（2）如果条件表达式1如果为假，就去判断条件表达式2是否成立，如果条件表达式2为真，就执行代码块2
（3）依次类推
（4）如果所有条件表达式不成立，则执行else的语句块
2）else 不是必须得
3）多分支最终只能执行一个代码块
多分支示例
package main
import (
"fmt"
)
func main(){
var c int
fmt.Println("输入成绩")
fmt.Scanln(&c)
if c == 100{
fmt.Println("奖励一辆bwm")
}else if c > 80 {
fmt.Println("奖励iPhone17")
}else if c >=60 {
fmt.Println("奖励iPad")
}else{
fmt.Println("继续努力吧")
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo04\main.go
// 输入成绩
// 100
// 奖励一辆bwm
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo04\main.go
// 输入成绩
// 78
// 奖励iPad
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo04\main.go
// 输入成绩
// 85
// 奖励iPhone17
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo04\main.go
// 输入成绩
// 45
// 继续努力吧
细节提示：if b = false{// golang if 条件判断不支持赋值;syntax error: cannot use assignment b = false as value
package main
import (
"fmt"
)
func main(){
var c int
fmt.Println("输入成绩")
fmt.Scanln(&c)
if c == 100{
fmt.Println("奖励一辆bwm")
}else if c > 80 {
fmt.Println("奖励iPhone17")
}else if c >=60 {
fmt.Println("奖励iPad")
}else{
fmt.Println("继续努力吧")
}
var b bool
// if b = false{// golang if 条件判断不支持赋值;syntax error: cannot use assignment b = false as value
if b == false{
fmt.Println("a")
}else if b {
fmt.Println("b")
}else if !b {
fmt.Println("c")
}else{
fmt.Println("d")
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo04\main.go
// 输入成绩
// 100
// 奖励一辆bwm
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo04\main.go
// 输入成绩
// 78
// 奖励iPad
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo04\main.go
// 输入成绩
// 85
// 奖励iPhone17
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo04\main.go
// 输入成绩
// 45
// 继续努力吧
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo04\main.go
// # command-line-arguments
// src\chapter04\demo04\main.go:19:7: syntax error: cannot use assignment b = false as value
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo04\main.go
// 输入成绩
// 80
// 奖励iPad
// a
示例
package main
import (
"fmt"
"math"
)
func main(){
var a float64 = 3.0
var w float64 = 100.0
var i float64 = 6.0
m := w * w - 4 * a * i
if m > 0 {
x1 := (-w + math.Sqrt(m))/2*a
x2 := (-w - math.Sqrt(m))/2*a
fmt.Printf("x1=%v x2=%v\n",x1,x2)
}else if m == 0{
x1 := (-w + math.Sqrt(m))/2*a
fmt.Printf("x1=%v x2=%v\n",x1)
} else {
fmt.Println("无解")
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo05\main.go
// x1=-0.5409755150261972 x2=-299.4590244849738
示例4
package main
import (
"fmt"
//"math"
)
func main(){
var t int
var c int
var s bool
fmt.Println("请输入你的身高、财产、是否帅")
fmt.Scanf("%d %d %t",&t,&c,&s)
if t > 180 && c > 1000 && s == true {
fmt.Println("嫁给他")
}else if t > 180 || c >1000 || s == true{
fmt.Println("嫁吧，比上不足，比下有余")
}else{
fmt.Println("不嫁")
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo06\main.go
// 请输入你的身高、财产、是否帅
// 185 1200 true
// 嫁给他
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo06\main.go
// 请输入你的身高、财产、是否帅
// 174 800 true
// 嫁吧，比上不足，比下有余
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo06\main.go
// 请输入你的身高、财产、是否帅
// 165 600 false
// 不嫁
嵌套分支
在一个分支结构中又完整嵌套了另一个分支，里面的分支的结构称为内层分支外面的分支结构称为外层分支结构
基本语法
if 条件表达式{
if 条件表达式{
}else{
}
}
示例1
package main
import (
"fmt"
//"math"
)
func main(){
var s int
var x bool
fmt.Println("请输入成绩")
fmt.Scanln(&s)
if s < 8 {
fmt.Println("请输入性别")
fmt.Scanln(&x)
if x {
fmt.Println("男子队进入决赛")
}else{
fmt.Println("女子对进入决赛")
}
}else{
fmt.Println("很遗憾未进入决赛")
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo07\main.go
// 请输入成绩
// 5
// 请输入性别
// true
// 男子队进入决赛
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo07\main.go
// 请输入成绩
// 5
// 请输入性别
// false
// 女子对进入决赛
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo07\main.go
// 请输入成绩
// 9
// 很遗憾未进入决赛
示例2
package main
import (
"fmt"
//"math"
)
func main(){
var s int
var y int
fmt.Println("输入当前月份")
fmt.Scanln(&y)
if y >= 1 && y <= 12 {
fmt.Println("输入年龄")
fmt.Scanln(&s)
if y >=4 && y <=10{
if s >= 18 && s <= 60 {
fmt.Println("旺季成年人票价60")
}else if s <18 {
fmt.Println("旺季儿童票价半价30")
}else {
fmt.Println("旺季老年人票价1/3 20")
}
} else {
if s >= 18 && s <= 60 {
fmt.Println("淡季成年人票价40")
}else{
fmt.Println("淡季儿童与老人票价20")
}
}
} else {
fmt.Println("输入当前月份错误")
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo08\main.go
// 输入当前月份
// 14
// 输入当前月份错误
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo08\main.go
// 输入当前月份
// 11
// 输入年龄
// 15
// 淡季儿童与老人票价20
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo08\main.go
// 输入当前月份
// 6
// 输入年龄
// 19
// 旺季成年人票价60
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo08\main.go
// 输入当前月份
// 7
// 输入年龄
// 65
// 旺季老年人票价1/3 20
switch 分支
1）switch 语句基于不同条件执行不同动作，每个case分支都是唯一的，从上到下匹配，直到匹配到为止
2）匹配项后面也不需要再加break
switch 表达式{
case 表达式1，表达式2.....:
语句块
case 表达式3，表达式4，...:
语句块2
//这里可以有多个case
default:
语句块：
}
流程图
1）switch 的执行流程是，先执行表达式，得到值，然后和case的表达式进行比较，如果相等，就匹配到，然后执行对应的case的语句块，最后退出Switch
2）如果switch的表达式的值没有和任何的case的表达式匹配成功，则执行default的语句块，执行后退出switch
3）golang 的case 后的表达式可以有多个，使用逗号间隔，
4）golang中case语句块，不需要写break ，因为默认会有，即当程序执行完case语句块后，默认情况下直接退出switch
示例
package main
import (
"fmt"
//"math"
)
func main(){
var z byte
fmt.Println("请从：a,b,c,d,e,f,g;选择一个")
fmt.Scanf("%c",&z)
//fmt.Scanln(&z);默认会转成整数
switch z {
case 'a':
fmt.Println("穿衣服a")
case 'b':
fmt.Println("穿衣服b")
case 'c':
fmt.Println("穿衣服c")
case 'd':
fmt.Println("穿衣服d")
case 'e':
fmt.Println("穿衣服e")
case 'f':
fmt.Println("穿衣服f")
case 'g':
fmt.Println("穿衣服g")
default:
fmt.Println("输入错误")
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo09\main.go
// 请从：a,b,c,d,e,f,g;选择一个
// a
// 穿衣服a
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo09\main.go
// 请从：a,b,c,d,e,f,g;选择一个
// c
// 穿衣服c
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo09\main.go
// 请从：a,b,c,d,e,f,g;选择一个
// o
// 输入错误
switch 细节
1）case 后面是表达式（即：常量值、变量、一个有返回值的函数等都可以）
package main
import (
"fmt"
//"math"
)
func test (chra byte) byte{
return chra + 1
}
func main(){
var z byte
fmt.Println("请从：a,b,c,d,e,f,g;选择一个")
fmt.Scanf("%c",&z)
//fmt.Scanln(&z);默认会转成整数
switch test(z) +1 {
case 'a':
fmt.Println("穿衣服a")
case 'b':
fmt.Println("穿衣服b")
case 'c':
fmt.Println("穿衣服c")
fallthrough
case 'd':
fmt.Println("穿衣服d")
case 'e':
fmt.Println("穿衣服e")
case 'f':
fmt.Println("穿衣服f")
case 'g':
fmt.Println("穿衣服g")
default:
fmt.Println("输入错误")
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo09\main.go
// b
// 穿衣服d
2）case 后的各个表达式的数据类型，必须和switch的表达式数据类型一致
package main
import (
"fmt"
//"math"
)
// package main
// import (
// "fmt"
// //"math"
// )
// func test (chra byte) byte{
// return chra + 1
// }
func main(){
var n1 int32 = 20
// var n2 int32 = 20
var n2 int64 = 20 // 报数据类型不匹配 invalid case n2 in switch on n1 (mismatched types int64 and int32)
switch n1 {
case n2://
fmt.Println("ok1")
default :
fmt.Println("没有匹配到")
}
}
3）case 后面可以带多个表达式，使用逗号隔开；如case 表达式1，表达式2....
package main
import (
"fmt"
//"math"
)
// func test (chra byte) byte{
// return chra + 1
// }
func main(){
var n1 int32 = 20
var n2 int32 = 20
// var n2 int64 = 20 // 报数据类型不匹配 invalid case n2 in switch on n1 (mismatched types int64 and int32)
switch n1 {
case n2, 10, 5:// 可以有多个表达式
fmt.Println("ok1")
default :
fmt.Println("没有匹配到")
}
}
4） case 后面的表达式如果是常量值（字面量），则要求不能重复
package main
import (
"fmt"
//"math"
)
// func test (chra byte) byte{
// return chra + 1
// }
func main(){
var n1 int32 = 20
var n2 int32 = 20
// var n2 int64 = 20 // 报数据类型不匹配 invalid case n2 in switch on n1 (mismatched types int64 and int32)
switch n1 {
case n2, 10, 5://
fmt.Println("ok1")
case 5://不允许
fmt.Println("ok2") //duplicate case 5 (constant of type int32) in expression switch
default :
fmt.Println("没有匹配到")
}
}
5) case 后面不需要break ，程序匹配到一个case后就会执行对应的代码块，然后退出switch，如果一个都匹配不到，则执行default
6)default语句不是必须得
7）switch 后也可以不带表达式，类似if--else 使用
package main
import (
"fmt"
//"math"
)
func main(){
var score int = 30
switch{
case score >90:
fmt.Println("优秀")
case score >=70 && score <=90:
fmt.Println("优良")
case score >=60 && score <70 :
fmt.Println("成绩及格")
default :
fmt.Println("不及格")
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo09\main.go
// 不及格
8）switch 后面可以声明定义变量，分号隔开，不推荐
var score int = 30
switch{
case score >90:
fmt.Println("优秀")
case score >=70 && score <=90:
fmt.Println("优良")
case score >=60 && score <70 :
fmt.Println("成绩及格")
default :
fmt.Println("不及格")
}
9）switch 穿透fallthrough，如果case 语句块后执行fallthrough，则继续执行下一个case 语句块；也叫switch 穿透
package main
import (
"fmt"
//"math"
)
func main(){
var i int = 10
switch i {
case 10:
fmt.Println("10")
fallthrough // 穿透
case 11:
fmt.Println("12") //执行
case 12:
fmt.Println("13")
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo09\main.go
// 11
// 12
10）Type switch switch语句还可以用来判断某个interface变量中实际指向的变量类型
示例
package main
import (
"fmt"
//"math"
)
func main(){
var i byte
fmt.Println("输入要转换的字符")
fmt.Scanf("%c",&i)
switch i {
case 'a':
fmt.Println("A")
case 'b':
fmt.Println("B")
case 'c':
fmt.Println("C")
case 'd':
fmt.Println("D")
case 'e':
fmt.Println("E")
default:
fmt.Println("other")
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo11\main.go
// 输入要转换的字符
// a
// A
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo11\main.go
// 输入要转换的字符
// g
// other
示例2
package main
import (
"fmt"
//"math"
)
func main(){
var s int
fmt.Println("输入成绩")
fmt.Scanln(&s)
switch {
case s > 100 :
fmt.Println("输入错误")
case s >= 60 :
fmt.Println("合格")
default:
fmt.Println("不合格")
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo11\main.go
// 输入成绩
// 80
// 合格
示例3
package main
import (
"fmt"
//"math"
)
func main(){
var x int
fmt.Println("输入月份")
fmt.Scanln(&x)
switch {
case x >=3 && x <=5 :
fmt.Println("春季")
case x >=6 && x <=8 :
fmt.Println("夏季")
case x >=9 && x <=11 :
fmt.Println("秋季")
case x <=2 || x == 12 :
fmt.Println("冬季")
default:
fmt.Println("输入错误")
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo12\main.go
// 输入月份
// 7
// 夏季
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo12\main.go
// 输入月份
// 10
// 秋季
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo12\main.go
// 输入月份
// 1
// 冬季
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo12\main.go
// 输入月份
// 2
// 冬季
示例4
package main
import (
"fmt"
//"math"
)
func main(){
var q string
fmt.Println("输入对应星期几")
fmt.Scanln(&q)
switch q{
case "星期一":
fmt.Printf("干煸豆角")
case "星期二":
fmt.Printf("醋溜土豆")
case "星期三":
fmt.Printf("红烧狮子头")
case "星期四":
fmt.Printf("油炸花生米")
case "星期五":
fmt.Printf("蒜蓉扇贝")
case "星期六":
fmt.Printf("东北乱炖")
case "星期日":
fmt.Printf("大盘鸡")
default:
fmt.Println("输入错误")
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo13\main.go
// 输入对应星期几
// 星期一
// 干煸豆角
switch 与if 的区别
1）如果判断的具体数值不多，而且符合整数，浮点数，字符，字符串，这几种类型，建议使用switch语句，简洁高效
2）其他情况：对区间判断和结果为bool类型的判断，使用if，if的使用范围更广
for 循环控制
基本语法
for 循环变量初始化；循环条件； 循环变量迭代{
循环操作语句
}
示例
package main
import (
"fmt"
)
func main(){
for i :=0; i<10;i++{
fmt.Println("你好，晨曦")
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo14\main.go
// 你好，晨曦
// 你好，晨曦
// 你好，晨曦
// 你好，晨曦
// 你好，晨曦
// 你好，晨曦
// 你好，晨曦
// 你好，晨曦
// 你好，晨曦
// 你好，晨曦
流程图
1）循环条件式返回一个布尔值的表达式
2）for 循环的第二种使用方式
for 循环判断条件{
循环体
}
将初始化和变量迭代写在其他位置
3）for 循环的第三种使用方法
for {
循环执行语句
}
上面写法等价 for ；；；{} 是一个无限循环，通常需要配合break使用
示例
package main
import (
"fmt"
)
func main() {
for i := 0; i < 3; i++ {
fmt.Println("你好，晨曦")
}
fmt.Println("*********************************")
j := 0
for j < 3 {
j++
fmt.Println("你好，Thanks♪(･ω･)ﾉ", j)
}
fmt.Println("**********************************")
y := 0
for {
//y := 0
y++
if y > 3 {//
break
}
fmt.Println("你好", y)
}
fmt.Println("***************************************")
t := 0
for {
if t < 3{
t++
fmt.Println("你好hh",t)
}else{
break
}
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo14\main.go
// 你好，晨曦
// 你好，晨曦
// 你好，晨曦
// *********************************
// 你好，Thanks♪(･ω･)ﾉ 1
// 你好，Thanks♪(･ω･)ﾉ 2
// 你好，Thanks♪(･ω･)ﾉ 3
// **********************************
// 你好 1
// 你好 2
// 你好 3
// ***************************************
// 你好hh 1
// 你好hh 2
// 你好hh 3
4）golang 提供for-range的方法，可以方便遍历字符串和数组
package main
import (
"fmt"
)
func main() {
str := "hello,world!北京"
for _,v := range str{
fmt.Printf("%c",v)
}
}
// 执行结果
//hello,world!北京
示例2
package main
import (
"fmt"
)
func main() {
str := "hello,world!北京"
for i,v := range str{
fmt.Printf("index=%d val=%c\n",i,v)
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo15\main.go
// index=0 val=h
// index=1 val=e
// index=2 val=l
// index=3 val=l
// index=4 val=o
// index=5 val=,
// index=6 val=w
// index=7 val=o
// index=8 val=r
// index=9 val=l
// index=10 val=d
// index=11 val=!
// index=12 val=北
// index=15 val=京
如果字符串含有中文，那么传统遍历字符串方式，就是错误的，会出现乱码。原因是传统的遍历是按照字节来遍历的，而一个汉字在utf8编码是对应3个字节。
示例 打印1~100之间所有9的倍数的个数以及和
package main
import (
"fmt"
)
func main() {
x :=0
j :=0
for i:=1;i<100;i++{
if i % 9 == 0 {
j ++
x = i + x
//fmt.Printf("%d+%d=%d\n",x,i)
}
}
fmt.Println("和",x)
fmt.Println("数量",j)
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo16\main.go
// 和 594
// 数量 11
示例2
package main
import (
"fmt"
)
func main() {
//var t int
for i:=0;i<=6;i++{
for j :=6;j>=0;j--{
if (i+j) == 6 {
fmt.Printf("%d + %d = %d\n",i,j,(i+j) )
}
}
}
fmt.Println("*******************************")
//优化
for i:=0;i<=6;i++{
j:= 6-i
fmt.Printf("%d + %d = %d\n",i,j,i+j )
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo17\main.go
// 0 + 6 = 6
// 1 + 5 = 6
// 2 + 4 = 6
// 3 + 3 = 6
// 4 + 2 = 6
// 5 + 1 = 6
// 6 + 0 = 6
// *******************************
// 0 + 6 = 6
// 1 + 5 = 6
// 2 + 4 = 6
// 3 + 3 = 6
// 4 + 2 = 6
// 5 + 1 = 6
// 6 + 0 = 6
while 和do ...while 的实现
golang 里面没有whille和do...while语法，需要注意，如果需要使用类似的其他语言，可以通过for循环实现其使用效果
1）for 循环实现while
循环初始化
for {
if 循环条件表达式{
break //跳出循环
}
循环操作（语句）
循环变量
}
多重循环控制
1）讲一个循环放在另一个循环体内，就形成了嵌套循环。在外边的for循环称为外层循环，在里面的for循环称为内层循环【建议一般使用两层，最多不超过3层】
2）实质上，嵌套循环就是把内层循环当成外层外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可以结束外层的档次循环，开始下一次的循环
3）设外层循环次数为m次，内层循环为n次，则内层循环体实际上需要执行m*n=mn次
示例
package main
import (
"fmt"
)
func main() {
var x int //所有班级学生成绩
for j:=1;j<3;j++{
var a int=0 // 班级所有成绩和
for i:=1;i<5;i++{
var s int=0 //学生成绩
fmt.Println("输入班级",j,"学生编号",i,"学生成绩")
fmt.Scanln(&s)
a += s
}
fmt.Println("平均成绩",a/5)
x += a
}
fmt.Println("所有班级平均分",x/15)
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo18\main.go
// 输入班级 1 学生编号 1 学生成绩
// 89
// 输入班级 1 学生编号 2 学生成绩
// 67
// 输入班级 1 学生编号 3 学生成绩
// 87
// 输入班级 1 学生编号 4 学生成绩
// 45
// 输入班级 1 学生编号 5 学生成绩
// 88
// 平均成绩 75
// 输入班级 2 学生编号 1 学生成绩
// 79
// 输入班级 2 学生编号 2 学生成绩
// 98
// 输入班级 2 学生编号 3 学生成绩
// 96
// 输入班级 2 学生编号 4 学生成绩
// 76
// 输入班级 2 学生编号 5 学生成绩
// 67
// 平均成绩 83
// 输入班级 3 学生编号 1 学生成绩
// 88
// 输入班级 3 学生编号 2 学生成绩
// 96
// 输入班级 3 学生编号 3 学生成绩
// 75
// 输入班级 3 学生编号 4 学生成绩
// 68
// 输入班级 3 学生编号 5 学生成绩
// 95
// 平均成绩 84
// 所有班级平均分 80
改进示例
package main
import (
"fmt"
)
func main() {
var x int //所有班级学生成绩
var p int = 0// 及格人数
for j:=1;j<4;j++{
var a int=0 // 班级所有成绩和
for i:=1;i<5;i++{
var s int=0 //学生成绩
fmt.Println("输入班级",j,"学生编号",i,"学生成绩")
fmt.Scanln(&s)
if s > 59{
p ++
}
a += s
}
fmt.Println("平均成绩",a/5)
x += a
}
fmt.Println("所有班级平均分",x/15)
fmt.Println("及格人数",p)
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo18\main.go
// 输入班级 1 学生编号 1 学生成绩
// 98
// 输入班级 1 学生编号 2 学生成绩
// 54
// 输入班级 1 学生编号 3 学生成绩
// 43
// 输入班级 1 学生编号 4 学生成绩
// 89
// 平均成绩 56
// 输入班级 2 学生编号 1 学生成绩
// 87
// 输入班级 2 学生编号 2 学生成绩
// 45
// 输入班级 2 学生编号 3 学生成绩
// 68
// 输入班级 2 学生编号 4 学生成绩
// 87
// 平均成绩 57
// 输入班级 3 学生编号 1 学生成绩
// 98
// 输入班级 3 学生编号 2 学生成绩
// 67
// 输入班级 3 学生编号 3 学生成绩
// 54
// 输入班级 3 学生编号 4 学生成绩
// 32
// 平均成绩 50
// 所有班级平均分 54
// 及格人数 7
打印金字塔
package main
import (
"fmt"
)
func main() {
// //i 表示层数
// for i := 0; i<10;i++{
// //j表示打印*
// for j:=0;j<10;j++{
// fmt.Printf("*")
// }
// fmt.Println("")
// }
fmt.Println("-----------------------------")
for i := 1; i<=10;i++{
for c :=1;c<=10-i;c++{
fmt.Printf(" ")
}
//j表示打印*
for j:=1;j<=i*2-1;j++{
if j == 1|| j == 2*i-1 || i == 10{// 判断第一个，最后一个；最后一行
fmt.Printf("*")
}else {
fmt.Printf(" ")
}
}
fmt.Println("")
}
fmt.Println("===========================")
for i :=1;i <=5;i++{
for k :=1; k<=5-i;k++{
fmt.Printf(" ")
}
for g :=1; g<=2*i-1;g++{
fmt.Printf("*")
}
fmt.Println()
}
fmt.Println("------------------------------")
var h int = 5
// fmt.Println("输入层数")
// fmt.Scanln(&h)
for i:=1;i<=h;i++{ //层数
//打印左侧空行
for j:=1; j<=h-i;j++{
fmt.Printf(" ")
}
for k:=1; k<=2*i-1;k++{
if k==1 || k==2*i-1 || i==h{// 第一个打印* 最后一行打印* ;最后一行全打印*
fmt.Printf("*")
}else{
fmt.Printf(" ")
}
}
fmt.Println()
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo19\main.go
// -----------------------------
// *
// * *
// * *
// * *
// * *
// * *
// * *
// * *
// * *
// *******************
// ===========================
// *
// ***
// *****
// *******
// *********
// ------------------------------
// *
// * *
// * *
// * *
// *********
分析
九九乘法表
package main
import (
"fmt"
)
func main() {
for i:=1;i<10;i++{
//fmt.Println(i)
for j := 1; j <= i ;j++{
fmt.Printf("%d * %d = %d ",j,i,(i*j))
fmt.Printf(" ")
}
fmt.Println("")
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo20\main.go
// 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
break 介绍
break 语句用于终止某个语句块执行，用于中断当前循环或跳出switch语句
流程图
示例
package main
import (
"fmt"
//"strconv"
"math/rand"
//"time"
)
func main() {
//rand.Seed(time.Now().Unix())
// n:=rand.Intn(100)+1
// fmt.Println(n)
var count int = 0
for {
//生成一个随机数，还需要rand设置一个种
//time.Now().Unix():返回一个从1970:01:01 的0时0分0秒到现在的一个秒数
//rand.Seed(time.Now().Unix())
n:=rand.Intn(100)+1
count ++
if n==99{
break
}
//fmt.Println(n)
}
fmt.Println(count)
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo21\main.go
// 7
跳转控制语句break
1) break 语句出现在多层嵌套的语句块中时，可以通过标签指明要终止哪一层语句块
2）标签的基本使用
label1： {
label2: {
label3: {
}
}
}
示例1
package main
import (
"fmt"
)
func main() {
for i:=0;i<4;i++{
for j:=0; j< 10;j++{
if j == 2{
break// 默认跳出最近循环
}
fmt.Println("j=",j)
}
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo21\main.go
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo21\main.go
// j= 0
// j= 1
// j= 0
// j= 1
// j= 0
// j= 1
// j= 0
// j= 1
示例2
package main
import (
"fmt"
//"strconv"
//"math/rand"
//"time"
)
func main() {
label1: //标签1
for i:=0;i<4;i++{
label2: //标签2
for j:=0; j< 10;j++{
fmt.Println("j=",j)
if j == 2{
break label1 // 终止标签1的循环
}else{
break label2 // 终止标签2的循环
}
}
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo21\main.go
// j= 0
// j= 0
// j= 0
// j= 0
break 默认会跳出最近for循环；break后面可以指定标签，跳出标签对应的for 循环
package main
import (
"fmt"
//"strconv"
//"math/rand"
//"time"
)
func main() {
label1:
for i :=1;i<100;i++{
for j :=1;j<100;j++{
if i + j > 20 {
fmt.Println(i,"加",j,"和大于20等于",i+j)
break label1
}
}
}
logchance :=3
for i := 1;i<=3;i++{
var name string
var pwd string
fmt.Println("请输入用户名")
fmt.Scanln(&name)
fmt.Println("请输入密码")
fmt.Scanln(&pwd)
if name == "张无忌" && pwd == "888" {
fmt.Println("恭喜登录成功")
break
}else{
logchance --
fmt.Println("你还有",logchance,"次机会，请珍惜")
}
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo22\main.go
// 1 加 20 和大于20等于 21
// 请输入用户名
// 张无忌
// 请输入密码
// 888
// 恭喜登录成功
跳转控制语句continue
基本介绍
1）continue语句用于结束本次循环，继续下一次循环
2）continue 语句出现在多层嵌套的循环语句体中，可以通过标签指明要跳过的是那一层循环，这个和前面的标签的使用的规则一样
基本语法
{
continue
}
流程图
示例
package main
import (
"fmt"
)
func main() {
for j:=0; j< 5;j++{
if j == 2{
continue
}
fmt.Println("j=",j)
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo21\main.go
// j= 0
// j= 1
// j= 3
// j= 4
示例
package main
import (
"fmt"
)
func main() {
for i:=1;i<10;i++{
if i % 2 == 0{
continue
}
fmt.Println(i)
}
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo24\main.go
// 1
// 3
// 5
// 7
// 9
示例
package main
import (
"fmt"
)
func main() {
var z int
var f int
for {
var x int
fmt.Println("输入一个数字")
fmt.Scanln(&x)
if x > 0{
z++
}else if x == 0{
fmt.Println("输入为0无法继续输入")
break
}else{
f++
}
}
fmt.Printf("输入正数个数%v，负数个数%v",z,f)
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo24\main.go
// 输入一个数字
// 89
// 输入一个数字
// 65
// 输入一个数字
// -98
// 输入一个数字
// 65
// 输入一个数字
// -97
// 输入一个数字
// -8
// 输入一个数字
// 3
// 输入一个数字
// 0
// 输入为0无法继续输入
// 输入正数个数4，负数个数3
示例
package main
import (
"fmt"
)
func main() {
sa :=100000.00
var w int
for {
if sa > 50000.00 {
sa = sa - sa * 0.05
w++
//fmt.Println(sa)
}else if sa <=50000.00&& sa>0{
sa -= 1000
w++
//fmt.Println(sa)
}else {
break
}
}
fmt.Printf("该人可以经过%v次路口",w)
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo24\main.go
// 该人可以经过63次路口
跳转控制语句goto
1)go 语言的goto语言可以无条件地转移到程序中指定的行
2)goto 语句通常与条件语句配合使用。可以实现条件转移，跳出循环体等功能
3)在go 程序设计中一般不主张使用goto，以免造成程序流程混乱，使理解和程序调试造成困扰
基础语法
goto label
label： statement
流程图
示例
package main
import (
//"crypto/x509"
"fmt"
)
func main() {
fmt.Println("ok1")
goto abc
fmt.Println("ok2")
fmt.Println("ok3")
fmt.Println("ok4")
fmt.Println("ok5")
abc:
fmt.Println("ok6")
fmt.Println("ok7")
fmt.Println("ok8")
fmt.Println("ok9")
fmt.Println("ok10")
fmt.Println("ok11")
}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter04\demo26\main.go
// ok1
// ok6
// ok7
// ok8
// ok9
// ok10
// ok11
跳转控制语句return
return 使用在方法里，表示跳出所在的函数或方法，在函数的时候，会详细介绍
草都可以从石头缝隙中长出来更可况你呢
浙公网安备 33010602011771号