go 流程控制-循环

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)
	}
}

打印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名同学,求出各个班的平均分和所有班级的平均分(学生的成绩从键盘输入)

func main()  {
	var classNum int = 3
	var stuNum int = 5
	var totalSum float64 = 0.0
	for i := 1; i <= classNum; i++ {
		var sum float64 = 0.0
		for j := 1; j <= stuNum; j++ {
			var score float64
			fmt.Printf("请输入第%d个班的第%d个同学的成绩: ", i, j)
			fmt.Scanln(&score)
			sum += score
		}
		fmt.Printf("第%d个班平均分为 %v\n", i, sum / float64(stuNum))
		totalSum += sum
	}
	fmt.Printf("所有班级的平均分为 %v\n", totalSum / float64(classNum))
}

打印金字塔

  *
 ***
*****

共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() {
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
	...
}

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函数，也就是终止程序