文章目录
- 流程控制语句
- 1.顺序控制
- 2.分支控制
- 2.1单分支
- 2.2双分支
- 单分支和双分支的四个题目
- switch分支结构
- 3.循环控制
- for循环控制
- while 和do...while的实现
- 4.跳转控制语句
- break
- continue
- goto
- return
- goto
- return
流程控制语句
介绍:在程序中,程序运行的流程控制决定程序如何执行的,是我们应该掌握的,主要有三大流程控制语句
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 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支持在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 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
}
}
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"
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整除
//第四题求润年
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 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案例介绍
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")
}
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("无解...")
}
//分析思路
//设计三个变量,需要从控制台输入
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
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("对不起你被淘汰了")
}
//案例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
基本语法
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 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的表达式数据类型一致
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
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分支来使用
//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后也可以直接声明/定义一个变量,分号结束,不推荐
//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的穿透 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()类似于多态操作
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”
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)
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,冬季
//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循环
案例
编写一个程序循环十次"你好刘承传"
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循环的第三种使用方法
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的方式,可以方便遍历字符串和数组(注:数组的遍历)
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转成了[]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的倍数的整数的个数及总和
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)完成下面的表达式输出
//第二题
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效果:先进行判断条件是否符合在进行循环输出
循环变量初始化
for {
if 循环条件表达式{
break //跳出for循环
}
循环操作(语句)
循环变量迭代
}
说明:
- for循环是一个无限循环
- break语句就是跳出循环
使用上面的while循环输出十句“hello world”
//使用while方式输出十句"hello world"
//循环变量初始化
var i int = 1
for {
if i>10 {
break //跳出循环结束过程
}
fmt.Println("hello world",i)
i++ //循环变量的迭代
}
使用do…while实现:先进行循环当条件不符合时就跳出循环
语法
循环变量初始化
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名同学,求出各个班的平均分和所有班级的平均分(学生成绩从键盘输入)
//案例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名同学
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)
}
打印一个矩形
//矩形
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(" ")
}
}
打印空心金字塔
//打印空心金字塔
/*
*
* *
****
分析:在我们给每行打印*号时需要考虑一个问题是打印*还是打印空格
每层的第一个和最后一个就是打印星星,其他的都打印空格
分析到例外情况,最底层是全部打印星星
*/
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(" ")
}
打印九九乘法表
/*
打印九九乘法表
*/
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 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的当前数。
func main(){
sum := 0
for i :=1;i <=100; i++ {
sum +=i //求和
if sum > 20 {
fmt.Println("当sum大于20时,这个数是:",i)
break
}
}
2)实现登录验证,有三次机会,如果用户名为“张无忌”,密码"888"提示登录成功,否则提示还有几次机会
//实现登录验证,有三次机会,如果用户名为“张无忌密码为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标签的使用的规则一样
基本语法
{
...
continue;
...
}
案例分析continue的使用
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的奇数
//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 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语句,以免造成程序流程的混乱,使理解与调试程序都产生困难
基本语法
goto label
...
label:statement
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
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案例
这里演示一下指定标签的形式来使用
*/
//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的奇数
//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 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语句,以免造成程序流程的混乱,使理解与调试程序都产生困难
基本语法
goto label
...
label:statement
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
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函数,也就是说终止程序