go语言学习【四】

目录如下：

1.for 循环控制
2.break语句和continue语句
3.函数
4.递归调用
5.闭包

1.for 循环控制

• 基本语法及简单案例

for 循环变量初始化；循环条件；循环变量迭代 {
             循环操作（语句）
}
 //简单案例：
for i:=1;i<7;i++ { //循环条件为false时，退出for循环
	  fmt.Println("hello")
 }

注意事项：
（1） 循环条件是返回一个布尔值的表达式

（2）Go语言没有 while 和 do…while 语法，可以通过 for 循环来实现其使用效果。

（3）Golang 提供 for-range 的方式，可以方便遍历字符串和数组。

package main
import "fmt"
func main() {
	//字符串遍历方式1-传统方式
	var str string = "hello,world!"
	for i:=0;i<len(str);i++ {
		fmt.Printf("%c",str[i]) //使用下标
	}
	fmt.Println()
	//字符串遍历方式2-for-range
	str = "yes ！"
	for index, val := range str { //把字符串str里的字符交给val，其对应的下标交给index
		fmt.Printf("index=%d val=%c\n",index,val)
	}
}

输出结果：

hello,world!
index=0 val=y
index=1 val=e
index=2 val=s
index=3 val=
index=4 val=！

注意：for-range 在遍历字符串时，是按照字符来遍历的，而不是按照字节，可以避免中文字符出现乱码的情况。使用传统方式输出中文，应把字符串 str 转成 []rune切片【 即 str 2:=[]rune (str)】

简单练习题：

// 1.打印1~100之间所有是9的倍数的整数的个数及总和
package main
import "fmt"
func main() {
	index:=0
    sum:=0
	for i:=1;i<=100;i++ {
		if i%9==0 {
			index++
			sum+=i
		}
	}
	fmt.Printf("index=%d sum=%d",index,sum)
	//输出结果：index=11 sum=594
}

// 2.统计三个班的平均分，每班5名同学，求各班平均分和所有班级平均分。
package main
import "fmt"
func main() {
	totalsum := 0.0
	for j:=1;j<=3;j++ {
		fmt.Printf("输入%d班的5名同学的成绩:",j)
		var sum float64 = 0.0
		for i:=1;i<=5;i++ {
			var score float64
			fmt.Scan(&score)
			sum+=score
		}
		fmt.Printf("%d班平均分是:%v\n",j,sum/5)
		totalsum+=sum
	}
	fmt.Printf("总平均分是:%v",totalsum/15)
}

输出结果：

输入1班的5名同学的成绩:87 89 68 72 80
1班平均分是:79.2
输入2班的5名同学的成绩:89 90 72 66 87
2班平均分是:80.8
输入3班的5名同学的成绩:90 82 94 96 80
3班平均分是:88.4
总平均分是:82.8

// 3.键盘输入一个整数，表示层数，打印出空心金字塔。
package main
import "fmt"
func main() {
	var n int 
	fmt.Println("请输入金字塔的层数：")
	fmt.Scan(&n)
	for i:=1;i<=n;i++ {
		//在每一层前面输出空格
		for k:=1;k<=n-i;k++ {
			fmt.Print(" ")
		}
		for j:=1;j<=2*i-1;j++ {
			if j==1 || j==2*i-1 || i==n {
			fmt.Print("*")
			} else {
				fmt.Print(" ")
			}
		}
		fmt.Println()
	}
}

输出结果：

// 4.打印九九乘法表
package main
import "fmt"
func main() {
	fmt.Println("九九乘法表如下:")
	for i:=1;i<=9;i++ {
		for j:=1;j<=i;j++ {
			fmt.Printf("%v * %v = %v \t",j,i,j*i)
			} 
		fmt.Println()
	}
}

输出结果：

2.break语句和continue语句

（1）break语句

• break语句用于终止某个语句块的执行，用于中断当前 for 循环或跳出 switch 语句。
• break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块。

package main
import "fmt"	
func main() {
	lable : //标签可以任意定义
	for i:=1;i<=4;i++ {
     for j:=0;j<=6;j++ {
	  if j==2 {
		break lable //如果只有break，则默认跳出最近的for循环。这里使用标签lable,跳出标签对应的for循环。
	} 
	fmt.Println("j=",j)
  }
 }
}

输出结果：

j= 0
j= 1

• 简单题目：

// 实现登录验证，有三次机会，如果用户名为“小张”，密码为666，提示登录成功。
// 否则提示还有几次机会。
package main
import "fmt"	
func main() {
	for i:=1;i<=3;i++ {
		fmt.Println("登录界面  请输入姓名:")
		var name string
		fmt.Scan(&name)
		fmt.Println("请输入密码:")
		var mima int
		fmt.Scan(&mima)
		if name=="小张"&& mima==666 {
			fmt.Println("登录成功")
			break
		} else {
			fmt.Printf("用户名或密码错误,还有%v次机会\n",3-i)
		}
	}
}

（2）continue语句

• continue语句用于结束本次循环，继续执行下一次循环。
• continue语句出现在多层嵌套的语句块中时，可以通过标签指明要跳过的是哪一层循环。

package main
import "fmt"	
func main() {
		for j:=0;j<=6;j++ {
		 if j==2 {
		   continue //当j=2时跳出本次循环，继续执行。只有j=2没有输出。
		 }
	   fmt.Println("j=",j)
	 }
}
输出结果：
j= 0
j= 1
j= 3
j= 4
j= 5
j= 6

• 练习题：

// 某人有100000元，每经过一次路口，需要交费，规则如下：
// 1.当现金>50000时，每次交5%
// 2.当现金<=50000时，每次交1000
// 编程计算该人可以经过多少次路口，使用 for + break 方式完成。
package main
import "fmt"	
func main() {
	var money float64 = 100000
	var n int = 0
	for {
		if money > 50000 {
			money*=0.95
		} else {
			money-=1000
			if money < 1000 {
				break
			}
		}
		n++
	}
	fmt.Printf("可以经过%v次路口",n)
}
输出结果:
可以经过61次路口

3.函数

在Go语言里，函数分为自定义函数和系统函数。

• 函数基本语法

func 函数名 (形参列表) (返回值列表) {
执行语句……
return 返回值列表
}
1.形参列表：表示函数的输入。
2.函数可以有返回值，也可以没有。

• 函数快速入门案例

package main
import "fmt"	
// 将计算功能放到一个函数中，在需要使用时调用即可。
func cal(n1 float64, n2 float64,ch byte) float64 { //返回值是float类型
	var res float64
switch ch {
case '+':
	res = n1 + n2
case '-':
	res = n1 - n2
case '*':
	res = n1 * n2
case '/':
	res = n1 / n2
	default :
	fmt.Println("操作符号错误……")
}
return res
}
func main() {
	var a float64 = 7.7
	var b float64 = 8.8
    var ch byte = '*'
	result := cal(a,b,ch)
	fmt.Printf("%v %c %v = %v",a,ch,b,result)
}
输出结果：7.7 * 8.8 = 67.76

4.递归调用

一个函数在函数体内又调用了本身，我们称为递归调用。

package main
import "fmt"
func test(n int) {
	if n>2 {
		n--
		test(n)
	}
	fmt.Println("n=",n)
}
func main() {
	n:=5
	test(n)
}

输出结果：

n= 2
n= 2
n= 3
n= 4

• 递归练习题：

// 1.斐波那契数
// 请使用递归的方式，求出斐波那契数1，1，2，3，5，8，13……
// 输入一个整数，求出对应的值。
package main
import "fmt"
func fac(n int) int {
	if n==1 || n==2 {
		return 1
	} else {
		return fac(n-1)+fac(n-2)
	}
}
func main() {
	fmt.Println("请输入一个整数：")
	var n int 
	fmt.Scan(&n)
	res := fac(n)
	fmt.Println("对应的值是：",res)
}

// 2.猴子吃桃问题
// 有一堆桃子，第一天吃掉一半多一个，第二天吃掉剩下的一半桃子多一个。
// 到第十天时，发现只剩下一个桃子。求一共有多少桃子。
package main
import "fmt"
func fac(n int) int {
	if n==10 {
		return 1
	} else {
		return (fac(n+1)+1)*2 //假设前一天桃子有x个,当天剩余y个。x/2-1=y,x=(y+1)*2
	}
}
func main() {
	var n int = 1
	res := fac(n)
	fmt.Println("桃子的总数是：",res)
}
// 输出结果：桃子的总数是： 1534

5.闭包

闭包就是一个函数和与其相关的引用环境组合的一个整体。

• 案例演示：

package main
import "fmt"
	//累加器
func AddUpper() func(int)int {
	var n int = 10 
	return func (x int) int {
		n = n + x
		return n //返回的是一个匿名函数，但是这个匿名函数引用到函数外的n，因此这个匿名函数和n形成一个整体，构成闭包。
	}
}
func main() {
    f := AddUpper()
	fmt.Println(f(1)) // 11
	fmt.Println(f(2)) // 13 
	fmt.Println(f(3)) // 16
	//当我们反复调用f函数时，因为n是初始化一次，因此每调用一次就进行累计。
}