for循环控制
让一段代码循环的执行
语法
for 循环变量初始化;循环条件;循环变量迭代 {
代码块
}
执行过程
- 1 循环变量初始化
- 2 循环条件
- 3 执行代码块
- 4 循环变量迭代
- 5 反复执行2, 3, 4, 直到循环条件为false,就退出循环
func main() {
for i :=1; i <= 10; i++ {
fmt.Println("hello world!")
}
}
语法2:
for 表达式 {
代码块
}
说明: 将变量初始化和变量迭代写到其它位置
func main() {
j := 1
for j <= 10 {
fmt.Println("hello world!")
j++
}
}
语法3:
for {
代码块
}
func main() {
k := 1
for {
if k <= 10 {
fmt.Println("hello world!")
} else {
break
}
k++
}
}
golang提供for-range的方式,可以方便遍历字符串和数组
func main() {
var str string = "hello,world!"
for i := 0; i < len(str); i++ {
fmt.Printf("%c \n", str[i])
}
}
func main() {
var str string = "hello,world!"
for index, val := range str {
fmt.Printf("index=%d, val=%c \n", index, val)
}
}
运行结果
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=!
-
如果字符串含有中文,传统的变量字符串方式就会错误,出现乱码,原因是传统的对字符串的遍历是按照字节来遍历,而一个汉字在utf8编码是对应3B
-
for-range遍历方式是按照字符方式遍历,因此如果有字符串有中文也ok
func main() {
var str string = "hello,world!北京"
for index, val := range str {
fmt.Printf("index=%d, val=%c \n", index, val)
}
}
package main
import "fmt"
func main() {
var str string = "hello,world!北京"
str2 := []rune(str)
for i := 0; i < len(str2); i++ {
fmt.Printf("%c\n", str2[i])
}
str = "abcok!"
for index, val := range str {
fmt.Printf("index=%d, val=%c\n", index, val)
}
}
打印1~100之间所有是9的倍数的整数的个数及总和
func main() {
var count int = 0
var sum int = 0
for i := 1; i <= 100; i++ {
if i % 9 == 0 {
count++
sum += i
}
}
fmt.Printf("count=%d, sum=%d", count, sum)
}
func main() {
var max int = 6
for i := 0; i <= max; i++ {
fmt.Printf("%v + %v = %v\n", i, max-i, max)
}
}
多重循环控制
-
将一个循环放在另一个循环体内,就形成了嵌套循环.在外边的for称为外层循环,在里面的for循环称为内层循环(建议一般使用两层,最多不要超过3层)
-
实质上,嵌套循环就是把内层循环当成外层循环的循环体.当只有内层循环的循环条件为false时,才会完全跳出内层循环,才可结束外层的当次循环,开始下一次循环
-
外层循环次数为m次,内层为n次,则内层循环体实际上需要执行m*n次
统计3个班的成绩情况,每个班5名同学,求出各个班的平均分和所有班级的平均分(学生的成绩从键盘输入)
package main
import "fmt"
func main() {
var classNum int = 2
var stuNum int = 5
var totalSum float64 = 0.0
var passCount int = 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 {
passCount++
}
}
fmt.Printf("第%d班级的平均分%v\n", j, sum / float64(stuNum))
totalSum += sum
}
fmt.Printf("所有班级总分=%v 所有班级平均分=%v\n", totalSum, totalSum / float64(stuNum * classNum))
fmt.Printf("及格人数为%v\n", passCount)
}
打印金字塔(先死后活思想)
*
***
*****
共3层
第1层: 3-1个空 2*1-1个*
第2层: 3-2个空 2*2-1个*
第3层: 3-3个空 2*3-1个*
package main
import "fmt"
func main() {
var totalLevel int = 3
for i := 1; i <= totalLevel; i++ {
for j := 1; j <= totalLevel - i; j++ {
fmt.Print(" ")
}
for h := 1; h <= 2 * i - 1; h++ {
fmt.Print("*")
}
fmt.Println("")
}
}
空心金字塔
package main
import "fmt"
func main() {
//i表示层数
//j表示每层打印多少*
var totalLevel int = 9
for i := 1; i <= totalLevel; i++ {
for k := 1; k <= totalLevel - i; k++ {
fmt.Print(" ")
}
for j := 1; j <= 2 * i - 1; j++ {
if j == 1 || j == 2 * i - 1 || i == totalLevel {
fmt.Print("*")
} else {
fmt.Print(" ")
}
}
fmt.Println()
}
}
运行结果
*
* *
* *
* *
* *
* *
* *
* *
*****************
打印九九乘法表
package main
import "fmt"
func main() {
for i := 1; i <= 9; i++ {
for j := 1; j <= i; j++ {
fmt.Printf("%v * %v = %v \t", j, i, j * i)
}
fmt.Println("")
}
}
跳转控制语句-break
break语句用于终止某个语句块的执行,用于中断当前for循环或跳出switch语句
{
...
break
...
}
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
//为了生成一个随机数,还需要个rand设置一个种子
//time.Now().Unix(): 返回一个从1970:01:01 的0时0分0秒到现在的秒数
//fmt.Println(time.Now().Unix())
//rand.Seed(time.Now().Unix())
//随机生成1-100整数
//n := rand.Intn(100) + 1
//fmt.Println(n)
var count int = 0
for {
rand.Seed(time.Now().UnixNano())
n := rand.Intn(100) + 1
count++
if n == 99 {
break
}
}
fmt.Println(count)
}
break注意事项
- break语句出现在多层嵌套的语句块中时,可以通过标签指明要终止的是哪一层语句块
- break默认会跳出最近的for循环
- break后面可以指定标签,跳出标签对应的for循环
package main
import "fmt"
func main() {
lable2:
for i := 0; i < 4; i++ {
//lable1:
for j := 0; j < 10; j++ {
if j == 2 {
//break //默认会跳出最近的for循环
//break lable1
break lable2
}
fmt.Println("j=", j)
}
}
}
随机生成1-100的一个数,直到生成99这个数,看看一共用了几次
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
var count int = 0
for {
rand.Seed(time.Now().UnixNano())
n := rand.Intn(100) + 1
fmt.Println("n=", n)
count++
if n == 99 {
break
}
}
fmt.Println("生成99 一共使用", count)
}
100以内的数求和,求出当和第一次大于20的当前数
package main
import (
"fmt"
)
func main() {
sum := 0
for i := 0; i < 100; i++ {
sum += i
if sum > 20 {
fmt.Println("当前数为", i)
break
}
}
}
登录验证,有三次机会,如果用户名为“五行哥”,密码为“666”,提示登录成功,否则提示还有几次机会
package main
import (
"fmt"
)
func main() {
var name string
var pass string
var loginCount = 3
for i := 1; i <= 3; i++ {
fmt.Println("请输入用户名:")
fmt.Scanln(&name)
fmt.Println("请输入密码:")
fmt.Scanln(&pass)
if name == "五行哥" && pass == "666" {
fmt.Println("登录成功!")
break
} else {
loginCount--
fmt.Printf("你还有%v次机会!!!\n", loginCount)
}
}
if loginCount == 0 {
fmt.Println("机会用完,没有登录成功...")
}
}
跳转控制语句-continue
- continue语句用于结束本次循环,继续执行下一次循环
- continue语句出现在多层嵌套的循环语句体中,可以通过标签指明要跳过的是哪一层循环,跟break规则一样
{
...
continue
...
}
打印1-100之内的奇数
package main
import (
"fmt"
)
func main() {
for i := 1; i <= 100; i++ {
if i % 2 == 0 {
continue
}
fmt.Println("奇数是", i)
}
}
从键盘读入个数不确定的整数,并判断读入的正数和负数的个数,输入为0时结束程序
package main
import (
"fmt"
)
func main() {
var positiveCount int
var negativeCount int
var num int
for {
fmt.Println("请输入一个整数:")
fmt.Scanln(&num)
if num == 0 {
break
}
if num > 0 {
positiveCount++
continue
}
negativeCount++
}
fmt.Printf("正数个数为%v 负数个数为%v\n", positiveCount, negativeCount)
}
某人有100000元,每经过一次路口,需要交费,规则如下:
当现金>50000时,每次交5%
当现金<=50000时,每次交1000
计算该人可以经过多少次路口
package main
import (
"fmt"
)
func main() {
var money float64 = 100000
var count int = 0
for {
if money <= 0 {
break
}
if money > 50000 {
money -= money * 0.05
count++
} else {
money -= 1000
count++
}
}
fmt.Printf("一共可以经过%v次路口\n", count)
}
跳转控制语句-goto
- go语言额goto语句可以无条件地转移到程序中指定的行
- goto语句通常与条件语句配合使用。可用来实现条件转移,跳出循环体等功能
- 在go程序设计中一般不主张使用goto语句,以免造成程序流程的混乱,使理解和调试程序都产生困难
goto label
...
label:
statement
package main
import (
"fmt"
)
func main() {
var n int = 30
fmt.Println("ok1")
if n > 20 {
goto label1
}
fmt.Println("ok2")
fmt.Println("ok3")
fmt.Println("ok4")
label1:
fmt.Println("ok5")
fmt.Println("ok6")
fmt.Println("ok7")
}
跳转控制语句-return
return使用在方法或函数中,表示跳出所在的方法或函数
package main
import (
"fmt"
)
func main() {
for i := 1; i <= 10; i++ {
if i == 3 {
return
}
fmt.Println("hehe", i)
}
fmt.Println("hello world!")
}
说明:
- 如果return使在普通的函数,则表示跳出该函数,即不再执行函数中return后面的代码,也可以理解成终止函数
- 如果return是在main函数,表示终止main函数,也就是终止程序