流程控制语句

介绍：在程序中，程序运行的流程控制决定程序如何执行的，是我们应该掌握的，主要有三大流程控制语句

1.顺序控制

介绍：程序从上到下逐行地执行，中间没有任何判断效果

一个案例说明，必须下面的代码，没有判断，也没有跳转。因此程序按照默认的流程执行。即顺序控制

var days int  = 97
var week int =days / 7
var day int = days % 7
fmt.Println("%d个星期零%d天",week,day)

流程图

顺序控制举例和注意事项

Golang中定义变量时采用合法额前向引用。如

func main(){
var num1 int = 0
var num2 int = num1 + 20
fmt.Println(num2)
}
错误形式：不可以先使用后声明
func main(){
var num2 int = num1 + 20 //错误，一定要注意先后顺序
var num1 int = 10
fmt,Println(num2)
}

2.分支控制

分支控制if-else介绍

让程序有选择的执行，分支控制有三种。

2.1单分支

基本语法

if 条件表达式{执行代码块
}
说明：当条件表达式为true时，就会执行{}的代码。
注意：{}是必须有的，就算你只写一行代码

应用案例

package mainimport ("fmt"
)
//编写一个程序可以输入一个人的年龄，
// 如果同志的年龄大于18岁则输出你的年龄大于18岁
//要对自己的行为负责//分析：年龄 ==》var age int
//2.从控制台接收输入func main(){
var age int
fmt.Println("请输入你的年龄:")
fmt.Scanln(&age)
if age >=18 {fmt.Println("你的年龄大于18岁，要为自己的行为所负责！")}
}

单分支细节说明

Go的if还有一个强大的地方就是条件判断语句里允许声明一个变量，这个变量的作用域只能在该条件逻辑块内，其他地方就不起作用了

//golang支持在if中，直接定义一个变量，比如下面的
if age := 20; age > 18{fmt.Println("你的年龄大于18岁，要为自己的行为所负责！")
}

2.2双分支

基本语法

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

func main(){
var age int
fmt.Println("请输入你的年龄:")
fmt.Scanln(&age)
if age >=18 {fmt.Println("你的年龄大于18岁，要为自己的行为所负责！")}else{//强制编程语法。else一定在这个地方fmt.Println("你的年龄不大，这次放过你了")}}

双分支细节

双分支只会执行其中的一个分支。

package mainimport ("fmt"
)
func main(){var x int = 1var y int = 1if(x>2){//golang中可以写小括号，但是官方不推荐就是if(y>2){fmt.Println(x+y)}fmt.Println("hello")}else{fmt.Println("x is =",x) //输出x=1}
}

var x int = 4
if > 2  //编译都不会通过，因为没有大括号fmt.Println("ok")
elsefmt.Println("helo")
//没有大括号就是错的。编译错误没有什么输出判断下列代码是否正确
var x int = 4
if x >2{fmt.Println("ok")
}//也是错的因为else要在这个括号的后面
else{fmt.Println("hello")
}
//编译错误，原因是else不能换行输出

单分支和双分支的四个题目

1）编写程序，声明2 个 int32型变量并赋值。判断两个数之和。如果大于等于50，打印“hello world"

var a int32 =45var b int32 =78if a+b>=50 {fmt.Println("这个数的和大于50")}

2)编写程序，声明2个float64型变量并赋值，判断第一个数大于10.0且第二个数小于20.0打印这两个数之和

 //第二题var c float64 =11.0var d float64 =17.0if c > 10.0 && d < 20.0 {fmt.Println("和=",(c+d)) //和=28}

3）定义两个变量int32 判断二者之和，是否能被3又被5整除，打印提示信息

//第三题var num1 int32 = 3var num2 int32 = 12if (num1 + num2) % 3 ==0 && (num1 + num2) % 5 == 0 {fmt.Println("能被三整除又可以被5整除")}

4）判断一个年份是否为闰年 ，闰年的条件时符合二者条件之一：（1）年份能被4整除但不能被100整除；（2）能被400整除

//第四题求润年fmt.Println("请输入相应的年份：")fmt.Scanf("%d",&year)if (year% 4==0 && year % 100 !=0) || year % 400 ==0{fmt.Printf("%d是润年",year)}else{fmt.Printf("%d不是润年",year)}

2.3多分支

基本语法:

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

对上面基本语法的说明

1）多分支的判断流程如下

（1）先判断条件表达式1是否成立，如果为真，就执行代码块1

（2）如果条件表达式1为假就继续判断条件表达式2是否成立，如果条件表达式2为真就执行代码块2，

（3）以此类推

（4）如果所有条件表达式不成立，则执行else的语句块。

2）else不是必须的

3）多分支最终只能有一个执行入口

流程图（更加清晰的说清楚）：

func main(){//多分支类型的理解/*岳小鹏参加golang考试，他和父亲岳不群达成承诺如果成绩100分奖励一台bmw成绩为(80,90)奖励一套iphone14当成绩（60,80）奖励一台ipad其他时，什么奖励都没有请从键盘输入岳小鹏的期末成绩，并加以判断*/var score intfmt.Println("请输入岳小鹏的成绩：")fmt.Scanf("%d",&score)if score==100{fmt.Println("奖励一台BMW")}else if score>80&&score<=99{fmt.Println("奖励一台iphone14")}else if score>=60&&score<=80{fmt.Println("奖励一个ipad")}else{fmt.Println("对不起，他什么都没有好好学习")}
}

分支控制if-else案例介绍

var b bool = trueif b= false{ //在这里不能赋值，只能写成==fmt.Println("a")}else if b {fmt.Println("b")}else if !b {fmt.Println("c")}else {fmt.Println("d")}

package mainimport ("fmt""math"
)
func main(){//分析思路//1.a,b,c是三个float64//2.使用到给出的书序公式//3.使用到多分支//4.使用到math.squr方法//走代码var a float64 =3.0var b float64 =1.0var c float64 =10.0m := b*b -4 * a * c//多分支判断if m>0 {x1 :=-b + math.Sqrt(m) / 2 * ax2 :=-b - math.Sqrt(m) / 2 * afmt.Printf("x1=%v,x2=%v",x1,x2)}else if m == 0 {x1 := (-b + math.Sqrt(m)) / 2 *afmt.Printf("x1=%v",x1)}else{fmt.Println("无解...")}

//分析思路//设计三个变量，需要从控制台输入var height int32var money float32var handsome boolfmt.Println("请你输入身高(厘米)")fmt.Scanln(&height)fmt.Println("请你输入财富")fmt.Scanln(&money)fmt.Println("帅吗")fmt.Scanln(&handsome)if height>180 && money>10000000.0 && handsome==true{fmt.Println("我一定要嫁给他")}else if height>180 || money>10000000.0 || handsome==true{fmt.Println("嫁吧，比上不足，比下有余")}else{fmt.Println("不嫁")}

嵌套分支

基本介绍：

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

基本语法

if条件表达式{if条件表达式{}else{}
}

注意：嵌套分支不宜过多，建议控制在3层内

应用案例1：

参加白米运动会，如果用时8秒以内进入决赛，否则提示淘汰。并且根据特别提示进入男子组或女子组，输入成绩和性别，进行判断

float64 second | string gender

var   second float64fmt.Println("请输入你的比赛成绩")fmt.Scanln(&second)//先判断是否进入决赛if second <=8{//进入决赛了var  gender stringfmt.Println("请问您的性别是")fmt.Scanln(&gender)if gender == "男"{fmt.Println("恭喜你进入男子组决赛")}else{fmt.Println("恭喜你进入女子组决赛")}}else{fmt.Println("对不起你被淘汰了")}

//案例2：出票系统
func main(){/*出票系统：根据淡旺季的月份和年龄。打印票价 【考虑学生先做】4~10旺季“成人（18-60）:60儿童（<18）:半价老人(>60)：1/3淡季：成人：40其他：20 //分析思路1.month age两个变量 byte2.使用嵌套分支*/var month bytevar age bytevar price float64 =60.0fmt.Println("请输入您旅游的月份")fmt.Scanln(&month)fmt.Println("请输入您旅游的年龄")fmt.Scanln(&age)if month>=4 && month<=10{if age > 60{fmt.Printf("票价是%v",price / 3)}else if age >=18{fmt.Printf("票价是%v",price)}else{fmt.Printf("票价： %v",price / 2)}}else{if age >=18 && age <60{fmt.Println("票价是",40)}else{fmt.Println("票价是",20)}}

switch分支结构

1）switch语句用于基于不同条件执行不同动作，。每一个case分支都是唯一的，从上到下逐一测试，直到匹配为止

2）匹配项后面也不需要再加break

基本语法

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

switch流程图

对上图的说明和总结

1）switch的执行的流程是，先执行表达式,得到值，然后和case表达式进行比较，如果相等，就匹配到，然后执行对应的case语句块，然后退出switch的控制

2）如果switch的表达式的值没有和任何表达式的值匹配成功，执行后退出switch机制

3)golang的表达式可以有多个，并且使用逗号间隔

4）golang中的case语句块不需要写break，因为默认就会有break.当程序执行完语句块之后，就直接退出该switch控制结构

案例：

请编写一个程序，该程序可以接收一个字符，比如：a,b,c,d,e,f a表示星期一， b表示星期二…根据用户输入显示相应的信息，要求使用switch语句完成

func main(){/*请编写一个程序，该程序可以接收一个字符，比如：a,b,c,d,e,f a表示星期一，b表示星期二...根据用户输入显示相应的信息，要求使用switch语句完成分析：1，定义一个变量接受字符2.使用switch完成*/var key bytefmt.Println("请输入一个字符  a b c d e f g")fmt.Scanf("%c",&key)switch key {case 'a':fmt.Println("周一")case 'b':fmt.Println("周二")case 'c':fmt.Println("周三")case 'd':fmt.Println("周四")case 'e':fmt.Println("周五")case 'f':fmt.Println("周六")case 'g':fmt.Println("周日")	default:fmt.Println("输入有误")						}

​ 关于switch的细节讨论

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

//写一个非常简单的函数
func test(b byte) byte {return b+1}
func main(){	var key bytefmt.Println("请输入一个字符  a b c d e f g")fmt.Scanf("%c",&key)switch test(key) { //调用、test函数

2）case后的各个表达式的值的数据类型，必须和switch的表达式数据类型一致

var n1 int32 = 20var n2 int32 = 20 //改为int64是错误的switch n1{//n2的类型需要与n1保持一致case n2 :fmt.Println("ok") //输出了okdefault:fmt.Println("输入有误")			}

3）case后面可以带多个表达式，使用逗号间隔。比如case表达式1，表达式2

var n1 int32 = 5var n2 int32 = 20 //改为int64是错误的switch n1{//n2的类型需要与n1保持一致case n2,10,5 : //case后面可以有多个表达值。匹配其中的一个就可以fmt.Println("ok") //输出了okdefault:fmt.Println("输入有误")			}

4)case后面的表达式如果是常量值（字面量）则要求不能重复

var n1 int32 = 20var n2 int32 = 20 //改为int64是错误的var n3 int32 =5switch n1{//n2的类型需要与n1保持一致case n2,10,5 : //case后面可以有多个表达值。匹配其中的一个就可以fmt.Println("ok") //输出了okcase 5://错误上面已经有一个匹配值了，我们不可以重复casefmt.Print("5")case n3: //这种情况是可以正常进行编译操作的的可以说是骗过了编译器fmt.Println("n3")default:fmt.Println("输入有误")			}

5）case后面不需要带break程序匹配到一个case后就会执行对应的代码块，然后退出switch,如果一个斗匹配不到则执行default

6）default语句不是必须的

我们不写default也可以

7）switch后也可以不带表达式，类似于if-else分支来使用

//switch后可以不带表达式，类似于if -else 分支来使用var age int = 10switch {case age ==10 :fmt.Println("age ==10")case age ==20 :fmt.Println("age ==20")case age ==30 :fmt.Println("age ==30")default :fmt.Println("没有匹配到")				}
//case中也可以就age的范围进行判断var score int = 90switch {case score > 90 :fmt.Println("成绩优秀")case score >=70 && score <=90 :fmt.Println("成绩优良")case score >=60 && score <70 :fmt.Println("成绩及格")default :fmt.Println("不及格")		}

8）switch后也可以直接声明/定义一个变量，分号结束，不推荐

//switch后也可以直接声明/定义一个变量,分号结束，并不推荐switch grade :=90; {case grade > 90 :fmt.Println("成绩优秀")case grade >=70 && grade <=90 :fmt.Println("成绩优良")case grade >=60 && grade <70 :fmt.Println("成绩及格")default :fmt.Println("不及格")		}

9）switch穿透-fallthough，如果在case语句块后增加fallthrough,则会继续执行下一个case也叫switch穿透

	//switch的穿透 fallthroughtvar num int = 10switch num{case 10 :fmt.Println("ok1")fallthrough  //默认只能穿透一层case 30 :fmt.Println("ok2")case 20 :fmt.Println("ok3")		default :fmt.Println("没有匹配到")				}

10)Type Switch ：switch语句还可以被用于 typ-switch来判断某个interface变量中实际指向的变量类型 xtype()类似于多态操作

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

案例:

1).使用switch把小写类型的char型转为大写（键盘输入）。只转换a,b,c,d,e,其他的输出“Other”

func main() {//1，使用switch将小写字符改为大写字母var char bytefmt.Println("请输入相应的字符")fmt.Scanf("%c",&char)switch char{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")						}

2)对学生成绩大于60分的，输出”合格"。低于60的输出“不合格”。（注：输入的成绩不能大于100）

 var score float64fmt.Println("请输入成绩")fmt.Scanln(&score)switch int(score / 60){case 1:fmt.Println("及格")	case 0:fmt.Println("不及格")	default:fmt.Println("输入有误...")

3）根据用户指定月份，打印该月份所属的季节。3,4,5.春季 6,7,8夏季 9,10,11秋季 12,1,冬季

//3,根据用户指定月份，打印该月份所属的季节。// 3,4,5.春季 6,7,8夏季 9,10,11秋季 12,1,// 冬季var month bytefmt.Println("请输入月份")fmt.Scanln(&month)switch month {case 3,4,5:fmt.Println("春季")case 6,7,8:fmt.Println("夏季")	case 9,10,11:fmt.Println("秋季")	case 12,1,2:fmt.Println("冬季")	default:fmt.Println("您输错了月份")	}

switch和if的比较

1）如果判断的具体数值不多，而且符合整数、浮点数、字符、字符串这几种类型。建议使用switch语句简洁高效

2）其他情况：对区间判断和结果为bool类型的判断，用if if的使用范围更广

3.循环控制

for循环控制

基本语法

for循环变量初始化;循环条件;循环变量迭代{循环操作（语句）
}

对上面的语法格式说明

1)对for循环来说，有四个要素

2)循环变量初始化

3)循环条件

4)循环操作（语句），有人也叫循环体。

5)循环变量的迭代

6)for循环执行的顺序

for循环执行的顺序说明

1）执行循环变量的初始化，比如 i :=1

2)执行循环条件，比如 i<=n

3)如果循环条件为真就执行循环操作

4)执行循环变量迭代

5)反复执行 2 3 4 步骤，直到循环条件为false就退出for循环

案例

编写一个程序循环十次"你好刘承传"

package mainimport ("fmt"
)
func main(){for i :=1;i<= 10;i++{fmt.Println("你好刘承传",i)}
}

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

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

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

for 循环判断条件 {//循环执行语句
}
将变量初始化和变量迭代写到其他的位置
案例：
//for循环的第二种写法j := 1 //循环变量初始化for j <= 10 { //循环条件fmt.Println("你好刘承传",j) //循环体j++  //循环变量的迭代}

3）for循环的第三种使用方法

for {//循环执行语句
}
上面的写法等价for ; ; {}是一个无限循环，通常需要配合break语句使用
//for循环的第三种写法,这种写法通常会配合break进行使用k :=1for { //此处等价 for ; ; ;{}if k <= 10{fmt.Print("helllo\n")}else{ //k>10时就break跳出break //break就是跳出整个for循环}k++}

for的注意事项和细节说明

4）Golang提供for-range的方式，可以方便遍历字符串和数组（注：数组的遍历）

way1传统方式进行遍历	
str := "hello world!"
for i :=0;i<len(str);i++{
fmt.Printf("i=%d val=%c\n",i,str[i])
}way2for-range方式进行遍历
func main(){
str :="hello,world!北京"
for index,val :=range str {
fmt.Printf("index=%d val=%c\n",index,val)
}注意：for-range在遍历字符串时，是按照字符来遍历的，而不是按照字节来的，请注意这点
}

上面的细节讨论：

如果我们的字符串含有中文，那么传统的遍历字符串方式，就是错误。会出现乱码，原因是对字符串的遍历是按照字节进行遍历的，而一个汉字在utf8编码对应的是3个字节

如何解决，需要将str []str切片

//传统方式对字符串进行切片str2 := []rune(str) //把str转成了[]runefor i :=0;i<len(str2);i++{fmt.Printf("i=%d val=%c\n",i,str2[i])}

对应for-range遍历字符串时，是按照字符串来遍历的，而不是按照字节来的。请注意这一点

for循环练习题

1）打印1~100之间所有是9的倍数的整数的个数及总和

func main(){var ge int = 0var sum int = 0for i :=1;i<=100;i++{if i % 9 ==0{ge++sum = sum + i}}fmt.Printf("1~100之间是9的倍数额整数个数为%d,总和为%d",ge,sum)
}

2）完成下面的表达式输出

//第二题var n int =6for i :=0;i<=n;i++{fmt.Printf("%v + %v= %v\n",i,n-i,n)}

while 和do…while的实现

Go语言没有while和do …while语法，我们可以使用for循环来实现其使用效果

1）for循环实现while效果：先进行判断条件是否符合在进行循环输出

循环变量初始化
for {if 循环条件表达式{break  //跳出for循环}循环操作（语句）循环变量迭代
}
说明：

1. for循环是一个无限循环
2. break语句就是跳出循环

使用上面的while循环输出十句“hello world”

//使用while方式输出十句"hello world"//循环变量初始化var i int = 1for {if i>10 {break  //跳出循环结束过程}fmt.Println("hello world",i)i++  //循环变量的迭代}

使用do…while实现:先进行循环当条件不符合时就跳出循环

语法

循环变量初始化
for {循环操作(语句)循环变量迭代if 循环条件表达式{break //跳出for循环}
}

对上图的说明

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

案例演示使用上面的dowhile实现输出十句helloworld

//使用do while的形式进行实现
var i int  = 1for {fmt.Println("hello world" ,i)i++ //循环变量进行迭代if i>10{break //跳出for循环}}

多重循环的控制

介绍：

1）将一个循环放在另一个循环体内，就形成了嵌套循环，在外边的for称为外层循环在里面的for循环称为内层循环（建议一般使用两层，最多不得超过三层）

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

3）设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n=nm次

应用实例

1》统计3个班级成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分（学生成绩从键盘输入）

//案例1/*1)统计3个班的成绩情况，每个班5名同学，求出各个班的平均分和所有班级的平均分（学生的成绩从键盘输入）分析实现思路1.统计一个班成绩情况，每个班有5名同学，求出这个班的平均分2.学生数就5个 3.声明一个变量sum统计班级的总分4.定义一个变量统计总成绩得出所有学生的平均分分析思路2要统计三个班，走三次分析思路31,将代码激活2.定义两个变量表示班级的个数和班级的人数代码实现*/var classNum int =2var stuNum int = 5var totalSum float64 = 0.0for j :=1;j <=classNum;j++{sum := 0.0for i := 1;i<=stuNum;i++{var score float64fmt.Printf("请输入第%d个班的第%d个学生成绩\n",j,i)fmt.Scanln(&score)//累计总分sum += score}fmt.Printf("第%d个班级的平均分是%v\n",j,sum / float64(stuNum))//将总分进行累加totalSum += sumfmt.Println("  ")}fmt.Printf("各个班级的总成绩是%v各个班级的平均分是%v",totalSum,totalSum/ float64(classNum * stuNum))
}

2》统计三个班及格人数，每个班有5名同学

func main(){//案例1/*1)统计3个班的成绩情况，每个班5名同学，求出各个班的平均分和所有班级的平均分（学生的成绩从键盘输入）分析实现思路1.统计一个班成绩情况，每个班有5名同学，求出这个班的平均分2.学生数就5个 3.声明一个变量sum统计班级的总分4.定义一个变量统计总成绩得出所有学生的平均分分析思路2要统计三个班，走三次分析思路31,将代码激活2.定义两个变量表示班级的个数和班级的人数//分析思路3统计班级及格人数1,声明一个变量用于保存及格人数代码实现*/var passc int = 0var classNum int =2var stuNum int = 5var totalSum float64 = 0.0for j :=1;j <=classNum;j++{sum := 0.0for i := 1;i<=stuNum;i++{var score float64fmt.Printf("请输入第%d个班的第%d个学生成绩\n",j,i)fmt.Scanln(&score)//累计总分sum += score//判断分数是否及格if score >=60{passc ++}}fmt.Printf("第%d个班级的平均分是%v\n",j,sum / float64(stuNum))//将总分进行累加totalSum += sumfmt.Println("  ")}fmt.Printf("各个班级的总成绩是%v各个班级的平均分是%v及格人数是%v",totalSum,totalSum/ float64(classNum * stuNum),passc)
}

打印一个矩形

//矩形
for i := 1;i<=5;i++{for j :=1;j<=5;j++{fmt.Printf("*")}fmt.Println(" ")}//左侧直角三角形for i := 1;i<=5;i++{for j :=1;j<=i;j++{fmt.Printf("*")}fmt.Println(" ")}
//打印金字塔案例2打印金字塔经典案例
案例分析
代码思路
1.打印一个金字塔*/var toleve int =9for i := 1;i<=toleve;i++{//在打印星号前打印空格for k :=1;k<=toleve-i;k++{fmt.Print(" ")}for j :=1;j<=2*i-1;j++{fmt.Printf("*")}fmt.Println(" ")}
}

打印空心金字塔

//打印空心金字塔/*** *****分析：在我们给每行打印*号时需要考虑一个问题是打印*还是打印空格每层的第一个和最后一个就是打印星星，其他的都打印空格分析到例外情况，最底层是全部打印星星*/var toleve int =9for i := 1;i<=toleve;i++{//在打印星号前打印空格for k :=1;k<=toleve-i;k++{fmt.Print(" ")}//在空格后面打印星星for j :=1;j<=2*i-1;j++{if j ==1 || j==2 * i -1 || i==toleve{fmt.Printf("*")}else{fmt.Print(" ")}}fmt.Println(" ")}

打印九九乘法表

/*打印九九乘法表*/for i:=1;i<=9;i++{for j:=1;j<=i;j++{fmt.Printf("%v * %v= %v  ",i,j,i*j)}fmt.Println(" ")}
}

4.跳转控制语句

break

看需求：

随机生成1-100的一个数，直到生成了99这个数，看看你一共用了几次

分析：编写一个无限循环的控制，然后不停地随机生成数，当生成了99时，就退出这个无限循环==》break

package mainimport ("fmt""math/rand""time"
)
func main() {//为了生成一个随机数，还需要个rand设置一个种子//time.Now().Unix():返回一个从1970:01:01的0分0秒到现在的秒数//rand.Seed(time.Now().Unix())//如何生成1-100的整数//n := rand.Intn(100) +1 //[0-100]故加一变成那个[1 100]// fmt.Println(n)/*思路：编写一个无限循环控制，然后不停的随机生成数，当生成了99时就退出这个无限循环==>break*/var count int = 0for {rand.Seed(time.Now().UnixNano())n := rand.Intn(100) +1 fmt.Println("n=",n)count ++if(n ==99){break //跳出for循环}}fmt.Printf("生成99一共使用了%v次",count)}

基本介绍:

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

基本语法

( ......
break;......
)

注意事项或细节说明

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

2）标签的基本使用

label1:{...
label2:  {...
label3:    {...break label2;....}}}

案例代码:

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

对案例的说明：

• break默认跳出最近的for循环
• break后面可以指定标签，跳出标签对应的for循环

break语句练习题

1)100以内的数求和，求出当和第一次大于20的当前数。

func main(){sum := 0for i :=1;i <=100; i++ {sum +=i //求和if sum > 20 {fmt.Println("当sum大于20时,这个数是：",i)break}}

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

//实现登录验证，有三次机会，如果用户名为“张无忌密码为888就提示登录成功//否则就提示还有几次机会var name stringvar passwd stringvar loginla int = 3for i:=1;i<=3;i++{fmt.Println("请输入姓名")fmt.Scanln(&name)fmt.Println("请输入密码")fmt.Scanln(&passwd)if name !="张无忌" || passwd != "888"{loginla --fmt.Printf("登录失败，你还有%v次机会\n",loginla)}else{fmt.Println("恭喜你登录成功")break}}

continue

基本介绍：

1）continue语句用于结束本次循环，继续执行下一次循环

2）continue语句出现在多层嵌套循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的break标签的使用的规则一样

基本语法

{...continue;...
}

案例分析continue的使用

func main() {/*continue案例这里演示一下指定标签的形式来使用*///label2for i := 0; i<4; i++{//label1:设置一个标签
for j :=0; j<10 ; j++{if j ==2 {continue}fmt.Println("j=",j)}}
}

输出4次134…9，但是每次都没有2在其中。

continue输出1~100的奇数

//1~100的奇数
for i:=1; i<=100; i++{if i%2!=0{fmt.Println(i)}else{continue}
}

从键盘读入个数不确定的整数，并判断读入额正数和负数额个数，输入为0时结束程序for循环break continue完成

func main() {var posicount intvar negacount intvar num intfor {fmt.Println("请输入一个整数")fmt.Scanln(&num)if num ==0 {break //终止for循环}if num >0 {posicount ++continue //结束本次循环，进入下一次循环}negacount ++}fmt.Printf("正数的个数是%v，负数的个数是%v",posicount,negacount)

goto

介绍：

1）Go语言的goto语句可以无条件地转移到程序中指定的行

2）goto语句通常与条件语句配合使用。可用来实现条件转移，跳出循环体等功能

3）在Go程序设计中一般不主张使用goto语句，以免造成程序流程的混乱，使理解与调试程序都产生困难

基本语法

goto label
...
label:statement

func main(){//演示goto的使用fmt.Println("ok1")goto lable1fmt.Println("ok2")fmt.Println("ok3")fmt.Println("ok4")lable1:fmt.Println("ok5")fmt.Println("ok6")fmt.Println("ok7")
}
//运行结果为：
ok1
ok5
ok6
ok7

return

return使用在方法，表示跳出所在的函数或方法

func main(){
for i :=1; i<=10; i++{
if i ==3{
return
}
fmt.Println(i)
}
fmt.Println("helloworld")
}

说明：

1）如果return 是在普通的函数，则表示跳出这个函数，即不再执行这个函数

}

案例分析continue的使用```go
func main() {/*continue案例这里演示一下指定标签的形式来使用*///label2for i := 0; i<4; i++{//label1:设置一个标签
for j :=0; j<10 ; j++{if j ==2 {continue}fmt.Println("j=",j)}}
}

输出4次134…9，但是每次都没有2在其中。

continue输出1~100的奇数

//1~100的奇数
for i:=1; i<=100; i++{if i%2!=0{fmt.Println(i)}else{continue}
}

从键盘读入个数不确定的整数，并判断读入额正数和负数额个数，输入为0时结束程序for循环break continue完成

func main() {var posicount intvar negacount intvar num intfor {fmt.Println("请输入一个整数")fmt.Scanln(&num)if num ==0 {break //终止for循环}if num >0 {posicount ++continue //结束本次循环，进入下一次循环}negacount ++}fmt.Printf("正数的个数是%v，负数的个数是%v",posicount,negacount)

goto

介绍：

1）Go语言的goto语句可以无条件地转移到程序中指定的行

2）goto语句通常与条件语句配合使用。可用来实现条件转移，跳出循环体等功能

3）在Go程序设计中一般不主张使用goto语句，以免造成程序流程的混乱，使理解与调试程序都产生困难

基本语法

goto label
...
label:statement

func main(){//演示goto的使用fmt.Println("ok1")goto lable1fmt.Println("ok2")fmt.Println("ok3")fmt.Println("ok4")lable1:fmt.Println("ok5")fmt.Println("ok6")fmt.Println("ok7")
}
//运行结果为：
ok1
ok5
ok6
ok7

return

return使用在方法，表示跳出所在的函数或方法

func main(){
for i :=1; i<=10; i++{
if i ==3{
return
}
fmt.Println(i)
}
fmt.Println("helloworld")
}

说明：

1）如果return 是在普通的函数，则表示跳出这个函数，即不再执行这个函数

2）如果return在main函数，表示终止main函数，也就是说终止程序