文章目录
流程控制语句
介绍：在程序中，程序运行的流程控制决定程序如何执行的，是我们应该掌握的，主要有三大流程控制语句
1.顺序控制
介绍：程序从上到下逐行地执行，中间没有任何判断效果
一个案例说明，必须下面的代码，没有判断，也没有跳转。因此程序按照默认的流程执行。即顺序控制
go
var days int = 97
var week int =days / 7
var day int = days % 7
fmt.Println("%d个星期零%d天",week,day)流程图
顺序控制举例和注意事项
Golang中定义变量时采用合法额前向引用。如
go
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时，就会执行{}的代码。
注意：{}是必须有的，就算你只写一行代码
应用案例
go
package main
import (
"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
//golang支持在if中，直接定义一个变量，比如下面的
if age := 20; age > 18{
fmt.Println("你的年龄大于18岁，要为自己的行为所负责！")
}2.2双分支
基本语法
if 条件表达式{
执行代码块1
}else{
执行代码块2
}
说明：当条件表达式成立，即执行代码块1，否则执行代码块2{}也是必须有的
go
func main(){
var age int
fmt.Println("请输入你的年龄:")
fmt.Scanln(&age)
if age >=18 {
fmt.Println("你的年龄大于18岁，要为自己的行为所负责！")
}else{//强制编程语法。else一定在这个地方
fmt.Println("你的年龄不大，这次放过你了")
}
}双分支细节
双分支只会执行其中的一个分支。
go
package main
import (
"fmt"
)
func main(){
var x int = 1
var y int = 1
if(x>2){//golang中可以写小括号，但是官方不推荐就是
if(y>2){
fmt.Println(x+y)
}
fmt.Println("hello")
}else{
fmt.Println("x is =",x) //输出x=1
}
}
go
var x int = 4
if > 2 //编译都不会通过，因为没有大括号
fmt.Println("ok")
else
fmt.Println("helo")
//没有大括号就是错的。编译错误没有什么输出
判断下列代码是否正确
var x int = 4
if x >2{
fmt.Println("ok")
}//也是错的因为else要在这个括号的后面
else{
fmt.Println("hello")
}
//编译错误，原因是else不能换行输出单分支和双分支的四个题目
1）编写程序，声明2 个 int32型变量并赋值。判断两个数之和。如果大于等于50，打印"hello world"
go
var a int32 =45
var b int32 =78
if a+b>=50 {
fmt.Println("这个数的和大于50")
}2)编写程序，声明2个float64型变量并赋值，判断第一个数大于10.0且第二个数小于20.0打印这两个数之和
//第二题
var c float64 =11.0
var d float64 =17.0
if c > 10.0 && d < 20.0 {
fmt.Println("和=",(c+d)) //和=28
}
3）定义两个变量int32 判断二者之和，是否能被3又被5整除，打印提示信息
//第三题
var num1 int32 = 3
var num2 int32 = 12
if (num1 + num2) % 3 ==0 && (num1 + num2) % 5 == 0 {
fmt.Println("能被三整除又可以被5整除")
}
4）判断一个年份是否为闰年 ，闰年的条件时符合二者条件之一：（1）年份能被4整除但不能被100整除；（2）能被400整除
go
//第四题求润年
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）多分支最终只能有一个执行入口
流程图（更加清晰的说清楚）：
go
func main(){
//多分支类型的理解
/*岳小鹏参加golang考试，他和父亲岳不群达成承诺
如果
成绩100分奖励一台bmw
成绩为(80,90)奖励一套iphone14
当成绩（60,80）奖励一台ipad
其他时，什么奖励都没有
请从键盘输入岳小鹏的期末成绩，并加以判断*/
var score int
fmt.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案例介绍
go
var b bool = true
if b= false{ //在这里不能赋值，只能写成==
fmt.Println("a")
}else if b {
fmt.Println("b")
}else if !b {
fmt.Println("c")
}else {
fmt.Println("d")
}
go
package main
import (
"fmt"
"math"
)
func main(){
//分析思路
//1.a,b,c是三个float64
//2.使用到给出的书序公式
//3.使用到多分支
//4.使用到math.squr方法
//走代码
var a float64 =3.0
var b float64 =1.0
var c float64 =10.0
m := b*b -4 * a * c
//多分支判断
if m>0 {
x1 :=-b + math.Sqrt(m) / 2 * a
x2 :=-b - math.Sqrt(m) / 2 * a
fmt.Printf("x1=%v,x2=%v",x1,x2)
}else if m == 0 {
x1 := (-b + math.Sqrt(m)) / 2 *a
fmt.Printf("x1=%v",x1)
}else{
fmt.Println("无解...")
}
go
//分析思路
//设计三个变量，需要从控制台输入
var height int32
var money float32
var handsome bool
fmt.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
go
var second float64
fmt.Println("请输入你的比赛成绩")
fmt.Scanln(&second)
//先判断是否进入决赛
if second <=8{
//进入决赛了
var gender string
fmt.Println("请问您的性别是")
fmt.Scanln(&gender)
if gender == "男"{
fmt.Println("恭喜你进入男子组决赛")
}else{
fmt.Println("恭喜你进入女子组决赛")
}
}else{
fmt.Println("对不起你被淘汰了")
}
go
//案例2：出票系统
func main(){
/*
出票系统：根据淡旺季的月份和年龄。打印票价 【考虑学生先做】
4~10旺季"
成人（18-60）:60
儿童（<18）:半价
老人(>60)：1/3
淡季：
成人：40
其他：20
//分析思路
1.month age两个变量 byte
2.使用嵌套分支
*/
var month byte
var age byte
var price float64 =60.0
fmt.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
基本语法
go
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语句完成
go
func main(){
/*
请编写一个程序，该程序可以接收一个字符，
比如：a,b,c,d,e,f a表示星期一，
b表示星期二...根据用户输入显示相应的信息，
要求使用switch语句完成
分析：
1，定义一个变量接受字符
2.使用switch完成
*/
var key byte
fmt.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 byte
fmt.Println("请输入一个字符 a b c d e f g")
fmt.Scanf("%c",&key)
switch test(key) { //调用、test函数
2）case后的各个表达式的值的数据类型，必须和switch的表达式数据类型一致
go
var n1 int32 = 20
var n2 int32 = 20 //改为int64是错误的
switch n1{//n2的类型需要与n1保持一致
case n2 :
fmt.Println("ok") //输出了ok
default:
fmt.Println("输入有误")
}3）case后面可以带多个表达式，使用逗号间隔。比如case表达式1，表达式2
go
var n1 int32 = 5
var n2 int32 = 20 //改为int64是错误的
switch n1{//n2的类型需要与n1保持一致
case n2,10,5 : //case后面可以有多个表达值。匹配其中的一个就可以
fmt.Println("ok") //输出了ok
default:
fmt.Println("输入有误")
}4)case后面的表达式如果是常量值（字面量）则要求不能重复
var n1 int32 = 20
var n2 int32 = 20 //改为int64是错误的
var n3 int32 =5
switch n1{//n2的类型需要与n1保持一致
case n2,10,5 : //case后面可以有多个表达值。匹配其中的一个就可以
fmt.Println("ok") //输出了ok
case 5://错误上面已经有一个匹配值了，我们不可以重复case
fmt.Print("5")
case n3: //这种情况是可以正常进行编译操作的的可以说是骗过了编译器
fmt.Println("n3")
default:
fmt.Println("输入有误")
}
5）case后面不需要带break程序匹配到一个case后就会执行对应的代码块，然后退出switch,如果一个斗匹配不到则执行default
6）default语句不是必须的
我们不写default也可以
7）switch后也可以不带表达式，类似于if-else分支来使用
go
//switch后可以不带表达式，类似于if -else 分支来使用
var age int = 10
switch {
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 = 90
switch {
case score > 90 :
fmt.Println("成绩优秀")
case score >=70 && score <=90 :
fmt.Println("成绩优良")
case score >=60 && score <70 :
fmt.Println("成绩及格")
default :
fmt.Println("不及格")
}8）switch后也可以直接声明/定义一个变量，分号结束，不推荐
go
//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穿透
go
//switch的穿透 fallthrought
var num int = 10
switch 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()类似于多态操作
go
var x interface{}
var y = 10.0
x = 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"
go
func main() {
//1，使用switch将小写字符改为大写字母
var char byte
fmt.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）
go
var score float64
fmt.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,冬季
go
//3,根据用户指定月份，打印该月份所属的季节。
// 3,4,5.春季 6,7,8夏季 9,10,11秋季 12,1,
// 冬季
var month byte
fmt.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循环
案例
编写一个程序循环十次"你好刘承传"
go
package main
import (
"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循环的第三种使用方法
go
for {
//循环执行语句
}
上面的写法等价for ; ; {}是一个无限循环，通常需要配合break语句使用
//for循环的第三种写法,这种写法通常会配合break进行使用
k :=1
for { //此处等价 for ; ; ;{}
if k <= 10{
fmt.Print("helllo\n")
}else{ //k>10时就break跳出
break //break就是跳出整个for循环
}
k++
}for的注意事项和细节说明
4）Golang提供for-range的方式，可以方便遍历字符串和数组（注：数组的遍历）
go
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切片
go
//传统方式对字符串进行切片
str2 := []rune(str) //把str转成了[]rune
for i :=0;i<len(str2);i++{
fmt.Printf("i=%d val=%c\n",i,str2[i])
}对应for-range遍历字符串时，是按照字符串来遍历的，而不是按照字节来的。请注意这一点
for循环练习题
1）打印1~100之间所有是9的倍数的整数的个数及总和
go
func main(){
var ge int = 0
var sum int = 0
for i :=1;i<=100;i++{
if i % 9 ==0{
ge++
sum = sum + i
}
}
fmt.Printf("1~100之间是9的倍数额整数个数为%d,总和为%d",ge,sum)
}2）完成下面的表达式输出
go
//第二题
var n int =6
for 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效果：先进行判断条件是否符合在进行循环输出
go
循环变量初始化
for {
if 循环条件表达式{
break //跳出for循环
}
循环操作（语句）
循环变量迭代
}
说明：- for循环是一个无限循环
- break语句就是跳出循环
使用上面的while循环输出十句"hello world"
go
//使用while方式输出十句"hello world"
//循环变量初始化
var i int = 1
for {
if i>10 {
break //跳出循环结束过程
}
fmt.Println("hello world",i)
i++ //循环变量的迭代
}使用do...while实现:先进行循环当条件不符合时就跳出循环
语法
go
循环变量初始化
for {
循环操作(语句)
循环变量迭代
if 循环条件表达式{
break //跳出for循环
}
}对上图的说明
- 上面的循环是先执行，再判断，因此至少执行一次
- 当循环条件成立后，就会执行break,break就是跳出for循环，结束for循环
案例演示使用上面的dowhile实现输出十句helloworld
//使用do while的形式进行实现
var i int = 1
for {
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名同学，求出各个班的平均分和所有班级的平均分（学生成绩从键盘输入）
go
//案例1
/*
1)统计3个班的成绩情况，每个班5名同学，
求出各个班的平均分和所有班级的平均分（学生的成绩从键盘输入
）
分析实现思路
1.统计一个班成绩情况，每个班有5名同学，求出这个班的平均分
2.学生数就5个
3.声明一个变量sum统计班级的总分
4.定义一个变量统计总成绩得出所有学生的平均分
分析思路2
要统计三个班，走三次
分析思路3
1,将代码激活
2.定义两个变量表示班级的个数和班级的人数
代码实现
*/
var classNum int =2
var stuNum int = 5
var totalSum float64 = 0.0
for j :=1;j <=classNum;j++{
sum := 0.0
for i := 1;i<=stuNum;i++{
var score float64
fmt.Printf("请输入第%d个班的第%d个学生成绩\n",j,i)
fmt.Scanln(&score)
//累计总分
sum += score
}
fmt.Printf("第%d个班级的平均分是%v\n",j,sum / float64(stuNum))
//将总分进行累加
totalSum += sum
fmt.Println(" ")
}
fmt.Printf("各个班级的总成绩是%v各个班级的平均分是%v",totalSum,totalSum/ float64(classNum * stuNum))
}2》统计三个班及格人数，每个班有5名同学
go
func main(){
//案例1
/*
1)统计3个班的成绩情况，每个班5名同学，
求出各个班的平均分和所有班级的平均分（学生的成绩从键盘输入
）
分析实现思路
1.统计一个班成绩情况，每个班有5名同学，求出这个班的平均分
2.学生数就5个
3.声明一个变量sum统计班级的总分
4.定义一个变量统计总成绩得出所有学生的平均分
分析思路2
要统计三个班，走三次
分析思路3
1,将代码激活
2.定义两个变量表示班级的个数和班级的人数
//分析思路3统计班级及格人数
1,声明一个变量用于保存及格人数
代码实现
*/
var passc int = 0
var classNum int =2
var stuNum int = 5
var totalSum float64 = 0.0
for j :=1;j <=classNum;j++{
sum := 0.0
for i := 1;i<=stuNum;i++{
var score float64
fmt.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 += sum
fmt.Println(" ")
}
fmt.Printf("各个班级的总成绩是%v各个班级的平均分是%v及格人数是%v",totalSum,totalSum/ float64(classNum * stuNum),passc)
}打印一个矩形
go
//矩形
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 =9
for 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(" ")
}
}
打印空心金字塔
go
//打印空心金字塔
/*
*
* *
****
分析：在我们给每行打印*号时需要考虑一个问题是打印*还是打印空格
每层的第一个和最后一个就是打印星星，其他的都打印空格
分析到例外情况，最底层是全部打印星星
*/
var toleve int =9
for 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(" ")
}
打印九九乘法表
go
/*
打印九九乘法表
*/
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
go
package main
import (
"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 = 0
for {
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;
....
}
}
}
案例代码:
//这里演示一下指定标签的形式使用 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) //j=0 j=1
}
}
对案例的说明：
- break默认跳出最近的for循环
- break后面可以指定标签，跳出标签对应的for循环
break语句练习题
1)100以内的数求和，求出当和第一次大于20的当前数。
go
func main(){
sum := 0
for i :=1;i <=100; i++ {
sum +=i //求和
if sum > 20 {
fmt.Println("当sum大于20时,这个数是：",i)
break
}
}2）实现登录验证，有三次机会，如果用户名为"张无忌"，密码"888"提示登录成功，否则提示还有几次机会
go
//实现登录验证，有三次机会，如果用户名为"张无忌密码为888就提示登录成功
//否则就提示还有几次机会
var name string
var passwd string
var loginla int = 3
for 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标签的使用的规则一样
基本语法
go
{
...
continue;
...
}案例分析continue的使用
go
func main() {
/*
continue案例
这里演示一下指定标签的形式来使用
*/
//label2
for 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的奇数
go
//1~100的奇数
for i:=1; i<=100; i++{
if i%2!=0{
fmt.Println(i)
}else{
continue
}
}从键盘读入个数不确定的整数，并判断读入额正数和负数额个数，输入为0时结束程序for循环break continue完成
go
func main() {
var posicount int
var negacount int
var num int
for {
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语句，以免造成程序流程的混乱，使理解与调试程序都产生困难
基本语法
go
goto label
...
label:statement
go
func main(){
//演示goto的使用
fmt.Println("ok1")
goto lable1
fmt.Println("ok2")
fmt.Println("ok3")
fmt.Println("ok4")
lable1:
fmt.Println("ok5")
fmt.Println("ok6")
fmt.Println("ok7")
}
//运行结果为：
ok1
ok5
ok6
ok7return
return使用在方法，表示跳出所在的函数或方法
go
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案例
这里演示一下指定标签的形式来使用
*/
//label2
for 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的奇数
go
//1~100的奇数
for i:=1; i<=100; i++{
if i%2!=0{
fmt.Println(i)
}else{
continue
}
}从键盘读入个数不确定的整数，并判断读入额正数和负数额个数，输入为0时结束程序for循环break continue完成
go
func main() {
var posicount int
var negacount int
var num int
for {
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语句，以免造成程序流程的混乱，使理解与调试程序都产生困难
基本语法
go
goto label
...
label:statement
go
func main(){
//演示goto的使用
fmt.Println("ok1")
goto lable1
fmt.Println("ok2")
fmt.Println("ok3")
fmt.Println("ok4")
lable1:
fmt.Println("ok5")
fmt.Println("ok6")
fmt.Println("ok7")
}
//运行结果为：
ok1
ok5
ok6
ok7return
return使用在方法，表示跳出所在的函数或方法
go
func main(){
for i :=1; i<=10; i++{
if i ==3{
return
}
fmt.Println(i)
}
fmt.Println("helloworld")
}说明：
1）如果return 是在普通的函数，则表示跳出这个函数，即不再执行这个函数
2）如果return在main函数，表示终止main函数，也就是说终止程序