Go语言基础第03天（循环函数和工程管理）

1.for循环

func main0101() {

	//for  表达式1 ; 表达式2 ; 表达式3{
	//循环体
	//}

	//for i:=1;i<=10;i++{
	//	fmt.Println(i)
	//}

	//计算1-100和
	//sum:=0
	//for i:=1;i<=100;i++{
	//	sum+=i//1+2+3.
	//}
	//fmt.Println(sum)

	//计算1-100之间偶数的和
	//sum:=0
	//for i:=1;i<=100 ;i++  {
	//	//在循环中嵌套条件判断语句
	//	if i%2==0{
	//		sum+=i
	//	}
	//}
	//fmt.Println(sum)
	sum := 0
	for i := 0; i <= 100; i += 2 {
		sum += i
	}
	fmt.Println(sum)
}

func main0102() {

	//for函数格式  i是在函数内部定义的不能在外部使用
	//局部变量
	//for i:=1;i<=10;i++{
	//	fmt.Println(i)
	//}

	//fmt.Println(i)//err

	//i:=1
	//for ;;{//i<=10
	//	if(i>10){
	//		//跳出循环
	//		break
	//	}
	//
	//	fmt.Println(i)
	//
	//	i++
	//}
	//fmt.Println(i)
	//死循环   在程序中要避免死循环出现 使用break 跳出循环
	for {
		fmt.Println("hello")
		break
	}
}

2.水仙花数

func main02() {
	for i:=100; i<1000;i++  {
		//百位
		a:=i/100
		//十位
		b:=i/10%10//b:=i%100/10
		//个位
		c:=i%10
		if a*a*a+b*b*b+c*c*c==i{
			fmt.Println(i)
		}
	}
}

3.敲七

func main03() {
	for i := 1; i <= 100; i++ {
		if i%7 == 0 || i%10 == 7 || i/10 == 7 {
			fmt.Println("敲桌子")
		} else {
			fmt.Println(i)
		}

	}

}

4.循环嵌套

func main0401() {

	//嵌套循环中  执行次数为外层*内层
	for i := 0; i < 5; i++ {

		for j := 0; j < 5; j++ {
			fmt.Println(i, j)
		}

	}
}

func main0402() {
	//九九乘法口诀
	/*
		1*1=1
		1*2=2 2*2=4
		1*3=3 2*3=6 3*3=9
		1*4=4 2*4=8 3*4=12 4*4=16
	*/
	//外层控制行  内层控制列
	for i := 1; i <= 9; i++ {
		for j := 1; j <= i; j++ {
			fmt.Print("*")
			//fmt.Printf("%d*%d=%d ",j,i,i*j)
			//if j==i{
			//	//在嵌套循环中 break 会跳出本次循环
			//	break
			//}
		}
		fmt.Println()
	}

}

5.跳出语句

func main05() {
	//break  在循环中跳出循环
	//continue 在嵌套循环中 跳出本层循环
	//goto 跳转坐标
	for i:=0;i<=100;i++ {
		//奇数
		if i%2==1{
			//结束本次循环继续下次循环
			continue
		}
		fmt.Println(i)
	}
}

6.百钱百鸡

func main0601() {
	//cock 公鸡 5钱
	//hen 母鸡 3钱
	//chicken 小鸡 1/3钱

	chicken := 0
	count := 0
	for cock := 0; cock <= 20; cock++ {
		for hen := 0; hen <= 33; hen++ {
			count++
			//计算剩余小鸡个数 100-公鸡-母鸡
			chicken = 100 - cock - hen
			if cock*5+hen*3+chicken/3 == 100 && chicken%3 == 0 {
				fmt.Printf("公鸡：%d 母鸡：%d 小鸡：%d\n", cock, hen, chicken)
			}
			//for chicken:=0;chicken<=100;chicken+=3{
			//	count++
			//	if (cock+hen+chicken==100) && (cock*5+hen*3+chicken/3==100){
			//		//fmt.Println("公鸡：",cock)
			//		//fmt.Println("母鸡：",hen)
			//		//fmt.Println("小鸡：",chicken)
			//		fmt.Printf("公鸡：%d 母鸡：%d 小鸡：%d\n",cock,hen,chicken)
			//
			//	}
			//}
		}
	}

	fmt.Println("执行次数：", count)
}

7.函数定义和使用

func add(a int, b int){
	sum:=a+b
	fmt.Println(sum)
}
func main0701() {

	//函数调用
	a1:=10
	b1:=20
	//在函数调用过程中 有具体的值成为实参  实际参数
	add(a1,b1)
	//函数可以重复调用
	add(1,2)

}

func swap(a int, b int){
	//a,b=b,a
	temp:=a
	a=b
	b=temp

	fmt.Println(a,b)
}
func main0702(){

	a:=10
	b:=20
	//形参和实参是不同的存储单元 在函数调用过程中 不会相互影响
	//在函数调用中使用的是实参  在函数定义中使用的形参
	swap(a,b)
	//a和b的值能交换吗？？
	//fmt.Println(a,b)

}

8.函数不定参数

func test(args ...int) {

	//fmt.Println(args)
	//len() 计算字符串有效长度
	//len() 计算不定参函数的长度
	for i := 0; i < len(args); i++ {
		fmt.Println("下标 ", i, "值 ", args[i])
	}

	//fmt.Println(len(args))
}

func plus(arr ...int) {
	sum := 0
	//for i:=0; i<len(arr);i++  {
	//	sum+=arr[i]
	//}
	//for 和range 可以遍历 集合中的数据信息  数组  切片 结构体数组  map
	for _, data := range arr {
		sum += data
	}
	fmt.Println(sum)
}

func main() {

	//test(1,2)
	//test(1,2,3,4)
	plus(1, 2)
	plus(1, 2, 3, 4)
	plus(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
}

for range遍历数组详解

语法

for key, value := range arr{
    //
}

for for range 循环使用的关键字。
key for range 循环返回的数组的索引。
value for range 循环返回数组的值的拷贝。
range for range 循环使用的关键字。
arr for range 循环需要遍历的数组数据。

for range遍历数组忽略key

for _, value := range data{
    //
}

如果，在循环中我们不需要 key 的数据，那么我们可以使用 匿名变量 的形式，来忽略 key 的值。这里的 value 就是数组的元素的拷贝。

for range遍历数组不写key

for value := range data{
    //
}

Go 语言 for range 循环也可以支持不写 key 的情况，即只写一个 value。这里的 value 就是数组的索引。

当使用 for range 循环(for range) 遍历数组时，key 返回的是数组的索引，value 返回的是索引对应的值的拷贝。如果我们不写 key，那么返回的就是数组元素的索引，而不是数组的元素值。

9.函数嵌套调用

func test2(a int, b int) {
	sum := a + b
	fmt.Println(sum)
}
func test1(a int, b int) {
	test2(a, b)
}

// 所有的函数都是全局函数 可以被项目中所有文件使用  在项目中函数名是唯一的
func main0901() {
	test1(10, 20)

}

func test3(a ...int) {
	//如果函数参数为不定参  传递方式为a[0:]...
	test4(a[0:]...)
	//test4(a[2:]...)
	//test4(a[:2]...)
	test4(a[1:3]...)
}
func main0902() {
	test3(1, 2, 3, 4)
	test3(5, 6, 7, 8)
}

// 函数的作用域是全局的  可以在项目中任意文件使用 不需要在意先后顺序
func test4(b ...int) {
	for i := 0; i < len(b); i++ {
		fmt.Println(i, b[i])
	}
}

10.函数返回值

// func  函数名（形参列表）返回值类型列表{代码体}
//
//	func sub(a int ,b int ) int {
//		sum:=a-b
//		//return 表示函数的结束  return 后面的代码不会执行 同时return也会将函数的返回值传递给主调函数
//		return sum
//		fmt.Println("helloworld")
//		fmt.Println("helloworld")
//		fmt.Println("helloworld")
//		return 0
//	}
//
// return可以写一个表达式 将表达式的结果作为返回值
//
//	func sub(a int, b int) int {
//		return  a-b
//	}

func sub(a int, b int) (sum int) {
	sum = a - b
	return
}
func main1001() {
	var value int
	value = sub(10, 20)

	fmt.Println(value)
}

// 函数多个返回值
// 如果函数没有参数在函数调用时()必须写
func test5() (a int, b int, c int) {
	//多重赋值
	a, b, c = 1, 2, 3
	return
}
func main1002() {
	//函数的返回值可以为主调函数赋值  可以通过返回值改变实参数据
	//a,b,c:=test5()
	//如果函数有多个返回值 但是不使用返回值 可以用匿名变量接收数据
	a, _, c := test5()
	fmt.Println(a)
	//fmt.Println(b)
	fmt.Println(c)
}

11.函数类型

func test6() {
	fmt.Println("瓜娃子")
}
func test7(a int, b int) {
	fmt.Println(a + b)
}
func test9(a int, b int) int {
	return a + b
}
func test8() {
	fmt.Println("细伢子")
}

// type 可以定义函数类型
// type 可以为已存在类型起别名
type FUNCTYPE func()
type FUNCTEST func(int, int)
type funcdemo func(int, int) int

func main1101() {
	//定义函数类型变量
	var f FUNCTYPE
	f = test6
	//通过函数变量调用函数
	f()

	//f=test7//err函数类型不一致
	//f()
	f = test8
	f()

	//函数类型 其实就是一个指针
	var f1 FUNCTEST
	f1 = test7
	f1(10, 20)

	var f2 funcdemo
	f2 = test9
	v := f2(10, 20)
	fmt.Println(v)
}

func test10(a int, b int) {
	fmt.Println(a + b)
}

func main1102() {
	//函数调用
	//test10(10,20)
	//如果使用Print打印函数名是一个地址
	//函数名本身就是一个指针类型数据  在内存中代码区进行存储
	//fmt.Println(test10)

	//自动类型推到创建函数类型
	//f:=test10
	//f(10,20)
	//fmt.Printf("%T",f)
	//直接定义函数类型
	var f func(int, int)
	f = test10
	f(10, 20)
}

12.函数数据作用域

func main1201() {
	//demo1()
	//局部变量  在函数内部定义的变量  作用域限定于本函数内部 从变量定义到本函数结束有效
	//var 变量名 数据类型 先定义后使用
	//在同一作用域范围内 变量名是唯一的
	//fmt.Printf(a)
	//a:=10
	匿名内部函数
	//{
	//	//var a int =20
	//	a:=20
	//	fmt.Println(a)
	//}
	//fmt.Println(a)

	//程序中如果出现了相同的变量名 如果本函数有自己的变量 就使用自己的 如果没有上外层寻找变量
	//如果名字相同会采用就进原则 使用自己的变量
	i := 0 //i:=0
	for i := 0; i < 10; i++ {

	}
	fmt.Println(i)

}

func main1202() {
	demo2()
	//采用就进原则使用局部变量
	//在局部变量作用域范围内 全局变量不起作用
	a := 234
	fmt.Println(a)
}

// 全局变量  在函数外部定义的变量成为全局变量
// 全局变量作用域是项目中所有文件
// 全局变量在内存中数据区存储 和const定义的常量存储位置都是数据区
var a int = 10 //如果全局变量没有初始值值为0

// 全局常量
const b int = 10

func demo2() {

	a = 123
	//const a int =10
	fmt.Println(a)
}