go学习之流程控制语句

文章目录

    • 流程控制语句
      • 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循环
    }
    循环操作(语句)
    循环变量迭代
}
说明:

  1. for循环是一个无限循环
  2. 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循环
   }
}

对上图的说明

  1. 上面的循环是先执行,再判断,因此至少执行一次
  2. 当循环条件成立后,就会执行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函数,也就是说终止程序

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/92344.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

【LeetCode75】第三十七题 二叉树中的最长交错路径

目录 题目&#xff1a; 示例&#xff1a; 分析&#xff1a; 代码&#xff1a; 题目&#xff1a; 示例&#xff1a; 分析&#xff1a; 给我们一棵二叉树&#xff0c;问我们在这棵树里能找到的最长交错路径。最长交错路径就是在二叉树里一左一右一左一右这样走&#xff0c;最…

Windows下搭建Tomcat HTTP服务,发布外网远程访问

文章目录 前言1.本地Tomcat网页搭建1.1 Tomcat安装1.2 配置环境变量1.3 环境配置1.4 Tomcat运行测试1.5 Cpolar安装和注册 2.本地网页发布2.1.Cpolar云端设置2.2 Cpolar本地设置 3.公网访问测试4.结语 前言 Tomcat作为一个轻量级的服务器&#xff0c;不仅名字很有趣&#xff0…

港联证券|燃气板块午后走高,美能能源涨停,水发燃气大幅拉升

燃气板块21日午后快速拉升&#xff0c;到发稿&#xff0c;美能动力涨停&#xff0c;水发燃气涨超7%&#xff0c;蓝天燃气涨超5%&#xff0c;贵州燃气涨逾4%。 消息面上&#xff0c;受澳大利亚LNG工厂罢工忧虑影响&#xff0c;欧洲基准天然气价格一度大涨18%。 有报导称&#x…

Zenity 简介

什么使 Zenity Zenity 是一个开源的命令行工具&#xff0c;它提供了一种简单的方式来创建图形化的用户界面&#xff08;GUI&#xff09;对话框&#xff0c;以与用户进行交互。它基于 GTK 库&#xff0c;可以在 Linux 和其他 UNIX-like 系统上使用。 Zenity 可以通过命令行或脚…

使用windeployqt和InstallShield打包发布Qt软件的流程

前言 Qt编译之后需要打包发布&#xff0c;并且发布给用户后需要增加一个安装软件&#xff0c;通过安装软件可以实现Qt软件的安装&#xff1b;用于安装软件的软件有很多&#xff0c;这里主要介绍InstallShield使用的流程&#xff1b; 使用windeployqt打包Qt编译后的程序 Qt程序…

Linux操作系统--文件与目录结构

我们初步认识了Linux操作系统,下面我们进一步看看linux的文件与目录结构。 1.文件系统和挂载点 (1).当前的操作系统中查看文件系统 位置 > 计算机 这样你就可以看见当前操作系统中的所有目录和文件。如下所示: (2).挂载点 挂载点实际上就是linux中的磁盘文件系统的入口…

Unittest 笔记:unittest拓展生成HTM报告发送邮件

HTMLTestRunner 是一个unitest拓展可以生成HTML 报告 下载地址&#xff1a;GitHub: https://github.com/defnnig/HTMLTestRunner HTMLTestRunner是一个独立的py文件&#xff0c;可以放在Lib 作为第三方模块使用或者作为项目的一部分。 方式1&#xff1a; 验证是否安装成功&…

STM32f103入门(2)流水灯蜂鸣器

流水灯 /* #define GPIO_Pin_0 ((uint16_t)0x0001) /*!< Pin 0 selected */ #define GPIO_Pin_1 ((uint16_t)0x0002) /*!< Pin 1 selected */ #define GPIO_Pin_2 ((uint16_t)0x0004) /*!< Pin 2 selected */ #de…

无涯教程-机器学习 - Jupyter Notebook函数

Jupyter笔记本基本上为开发基于Python的数据科学应用程序提供了一个交互式计算环境。它们以前称为ipython笔记本。以下是Jupyter笔记本的一些功能,使其成为Python ML生态系统的最佳组件之一- Jupyter笔记本可以逐步排列代码,图像,文本,输出等内容,从而逐步说明分析过程。 它有…

带你启用window10专业版系统自带的远程桌面

启用window10专业版系统自带的远程桌面 文章目录 启用window10专业版系统自带的远程桌面前言1.找到远程桌面的开关2. 找到“应用”项目3. 打开需要远程操作的电脑远程桌面功能 总结 前言 Windows操作系统作为应用最广泛的个人电脑操作系统&#xff0c;在我们身边几乎随处可见。…

JavaWeb学习-Day10

SpringBootWeb案例 准备工作 开发流程&#xff1a; 开发接口步骤&#xff1a; 删除部门&#xff1a; 新增部门&#xff1a; 简化代码&#xff1a; limit:分页展示&#xff0c;公式&#xff1a;&#xff08;页数-1&#xff09;*页面总数&#xff0c;页面总数 目前出现的问题&am…

【Eclipse】汉化简体中文教程(官方汉化包,IDE自带软件安装功能),图文详情

目录 0.环境 1.步骤 1&#xff09;查看eclipse的版本 2&#xff09;在官网找语言包&#xff0c;并复制链接 3&#xff09;将链接复制到eclipse中 4&#xff09;汉化完成 0.环境 windows11&#xff0c;64位&#xff1b; eclipse 2021-6版本 1.步骤 思路&#xff1a;在官网找…

MVC OR DDD

MVC OR DDD 说明&#xff1a;这篇是标题党&#xff0c;不包含相关概念说明 前段时间跟随师兄学习了解了DDD领域驱动模型&#xff0c;觉得这个思想更好&#xff0c;进行下面解析和学习方面的思考和实践&#xff0c;觉得很好&#xff0c;耐心读下去。希望对您有所帮助。 首先&am…

Nginx详解 一:编译安装Nginx和Nginx模块

文章目录 1.HTTP 和 Nginx1.1 Socket套接字1.2 HTTP工作机制1.2.1一次http事务1.2.2 资源类型1.2.3提高HTTP连接性能 2. I/O模型2.1 I/O模型相关概念2.2 网络I/O模型2.2.1 **阻塞型** **I/O** 模型&#xff08;blocking IO&#xff09;2.2.2 **非阻塞型** **I/O** **模型** **(…

开始MySQL之路—— DDL语法、DML语法、DQL语法基本操作详解

DDL语法 DDL&#xff08;Data Definition Language&#xff09; 数据定义语言&#xff0c;该语言部分包括以下内容。 对数据库的常用操作 对表结构的常用操作 修改表结构 对数据库的常用操作 1: 查看当前所有的数据库 show databases; 2&#xff1a;创建数据库 create dat…

回归预测 | MATLAB实现SSA-ELM麻雀搜索算法优化极限学习机多输入单输出回归预测(多指标,多图)

回归预测 | MATLAB实现SSA-ELM麻雀搜索算法优化极限学习机多输入单输出回归预测&#xff08;多指标&#xff0c;多图&#xff09; 目录 回归预测 | MATLAB实现SSA-ELM麻雀搜索算法优化极限学习机多输入单输出回归预测&#xff08;多指标&#xff0c;多图&#xff09;效果一览基…

2000-2021年上市公司绿色投资环保投资与营业收入之比数据(原始数据+计算代码+计算结果)

2000-2021年上市公司绿色投资环保投资与营业收入之比数据&#xff08;原始数据计算代码计算结果&#xff09; 1、时间&#xff1a;2000-2021年 2、来源&#xff1a;上市公司年报 3、指标&#xff1a;证券代码、企业名称、年份、管理费用环保投资、管理费用环保投资/营业收入…

第 360 场 LeetCode 周赛题解

A 距离原点最远的点 串中的 “_” 处要么都向左走要么都向右走 class Solution { public:int furthestDistanceFromOrigin(string moves) {int t 0;for (auto x: moves)if (x ! R)t--;elset;int res abs(t);t 0;for (auto x: moves)if (x ! L)t;elset--;res max(res, abs(t…

0821|C++day1 初步认识C++

一、思维导图 二、知识点回顾 【1】QT软件的使用 1&#xff09;创建文件 创建文件时&#xff0c;文件的路径一定是全英文 2&#xff09;修改编码 工具--->选项--->行为--->默认编码&#xff1a;system 【2】C和C的区别 C又叫C plus plus&#xff0c;C是对C的扩充&…

基于React实现日历组件详细教程

前言 日历组件是常见的日期时间相关的组件&#xff0c;围绕日历组件设计师做出过各种尝试&#xff0c;展示的形式也是五花八门。但是对于前端开发者来讲&#xff0c;主要我们能够掌握核心思路&#xff0c;不管多么奇葩的设计我们都能够把它做出来。 本文将详细分析如何渲染一…