Go语言基础第04天（工程管理和数组）

1.匿名函数

func main0101() {

	a:=10
	b:=20

	//匿名内部函数
	//f  是函数类型对应的变量
	// f:=func (a int , b int){
	// 	fmt.Println(a+b)
	// }
	
	// f(a,b)
	// f(20,30)

	f:=func(){
		fmt.Println("hello world")
	}
	f()
	f()
	f()

}

func main0102() {
	a := 10
	b := 20
	//匿名函数  带返回值的匿名函数
	//v:=func(a int, b int)int{
	//	return a+b
	//}(a,b)
	f := func(a int, b int) int {
		return a + b
	}
	//函数调用 f 函数类型  v 接收返回值  类型为int
	v := f(a, b)
	fmt.Printf("%T", f)

	//func (){
	//
	//}()
	//{
	//
	//}

	fmt.Println(v)
	fmt.Printf("%T", v)
}

2.闭包

func test1(a int) {
	a++
	fmt.Println(a)
}

func main0201() {
	a := 0
	for i := 0; i < 10; i++ {
		test1(a)
	}
}

// 可以通过匿名函数和闭包 实现函数在栈区的本地化
func test2() func() int {
	var a int

	return func() int {
		a++
		return a
	}
}
func main0202() {
	//将test2函数类型赋值给f
	//f:=test2
	//函数调用 将test2的返回值给f
	f := test2()
	//var a int
	//f:=func()  int{
	//	a++
	//	return a
	//}
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
	//fmt.Printf("%T",f)
}

3.递归函数

// 在函数定义时调用函数本身 递归函数
// 死递归
func test3(a int) {
	//在递归函数中一个要有出口  return
	if a == 0 {
		return
	}
	a--
	fmt.Println(a)
	test3(a)
}

func main0301() {

	test3(10)
}

// 计算n的阶乘
var sum int = 1

func test4(n int) {
	if n == 1 {
		return
	}

	test4(n - 1)
	sum *= n
}

func main0302() {
	test4(3)

	fmt.Println(sum)
}

4.数组

func main0401() {

	//var 变量名 数据类型

	//数组定义和使用
	//var 数组名 [元素个数]数据类型
	//var arr [10]int
	//
	////数组名[下标]=值
	//
	//arr[0]=123
	//arr[1]=10

	//数组下标是从0开始的  到数组下标的最大值为数组元素个数-1
	var arr [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

	//fmt.Println(arr[0])
	//fmt.Println(arr[1])
	//fmt.Println(arr[2])
	//fmt.Println(arr[3])
	////打印数组名可以显示所有元素
	//fmt.Println(arr)

	//打印数组信息
	//for i:=0;i<10;i++{
	//	fmt.Println(arr[i])
	//}

	//len(string) 获取字符串有效长度
	//len(...int) 获取不定参函数参数个数
	//len([10]int) 计算数组元素个数

	//fmt.Println(len(arr))
	//for i := 0; i < len(arr); i++ {
	//	fmt.Println(arr[i])
	//}

	//range 遍历集合信息
	//返回值为 下标  值
	for _, v := range arr {
		fmt.Println(v)
	}
}

func main0402() {
	//数组在定义时 可以初始化部分元素的值
	//var arr [10]int=[10]int{1,2,3,4,5}
	//使用自动类型推导创建数组
	//arr:=[10]int{1,2,3,4,5,6,7,8,9,10}

	//使用自动类型推导 可以根据元素个数创建数组
	arr := [...]int{1, 2, 3}

	for _, v := range arr {
		fmt.Println(v)
	}
	fmt.Printf("%T", arr)
}

func main0403() {
	//arr:=[5]int{1,2,3,4,5}
	//在定义时 叫元素个数
	var arr [5]int = [5]int{1, 2, 3, 4, 5}
	//在数组使用时叫下标 （0~len(arr)-1）
	//arr[5]=100//数组下标越界
	//arr[-1]=20//数组下标越界
	//数组在定义后 元素个数就已经固定 不能添加
	//fmt.Println(arr)
	//数组是一个常量 不允许赋值 数组名代表整个数组
	//arr=10//err
	//数组名也可以表示数组的首地址
	fmt.Printf("%p\n", &arr)
	fmt.Printf("%p\n", &arr[0])
	fmt.Printf("%p\n", &arr[1])
}

func main0403() {
	//arr:=[5]int{1,2,3,4,5}
	//在定义时 叫元素个数
	var arr [5]int = [5]int{1, 2, 3, 4, 5}
	//在数组使用时叫下标 （0~len(arr)-1）
	//arr[5]=100//数组下标越界
	//arr[-1]=20//数组下标越界
	//数组在定义后 元素个数就已经固定 不能添加
	//fmt.Println(arr)
	//数组是一个常量 不允许赋值 数组名代表整个数组
	//arr=10//err
	//数组名也可以表示数组的首地址
	fmt.Printf("%p\n", &arr)
	fmt.Printf("%p\n", &arr[0])
	fmt.Printf("%p\n", &arr[1])
}

5.小猪称体重

package main

import "fmt"

func main0501() {
	arr := [10]int{9, 1, 5, 6, 7, 3, 10, 2, 4, 8}

	max := arr[0]

	for i := 1; i < len(arr); i++ {
		if max < arr[i] {
			max = arr[i]
		}
	}
	fmt.Println("最重的小猪体重：", max)
}

6.数组置换

package main

import "fmt"

func main0601() {
	arr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

	//定义起始和结束下标
	start := 0
	end := len(arr) - 1

	for {
		if start > end {
			break
		}
		arr[start], arr[end] = arr[end], arr[start]

		start++
		end--
	}

	fmt.Println(arr)
}

7.冒泡排序

func main0701() {
	arr := [10]int{9, 1, 5, 6, 7, 3, 10, 2, 4, 8}

	//外层控制行
	for i := 0; i < len(arr)-1; i++ {
		//内层控制列
		for j := 0; j < len(arr)-1-i; j++ {
			//比较两个相邻元素 满足条件交换数据
			//升序排序 使用大于号 降序排序 使用小于号
			if arr[j] > arr[j+1] {
				arr[j], arr[j+1] = arr[j+1], arr[j]
			}
		}
	}

	fmt.Println(arr)
}

8.数组做函数参数

func test(arr [10]int) {
	//
	//for i := 0; i < len(arr); i++ {
	//	fmt.Println(arr[i])
	//}
	arr[2] = 123

	fmt.Printf("%p\n", &arr)

}
func main0801() {
	//指定数组下标进行初始化操作
	//var arr [10]int=[10]int{1,2,3,4,5,7:10}

	arr := [10]int{9, 1, 5, 6, 7, 3, 10, 2, 4, 8}
	//数组作为函数参数是传递数组名
	//数组作为函数参数是值传递的
	test(arr)
	//fmt.Println(arr)
	fmt.Printf("%p\n", &arr)
	//fmt.Println(arr)
}

9.随机数

func main() {
	//1、导入头文件 math/rand time
	//2、添加随机数种子
	//3、使用随机数
	start := time.Now().Nanosecond()
	//创建随机数种子
	rand.Seed(time.Now().UnixNano())
	for i := 0; i < 2; i++ {
		//根据时间 1970.1.1.0.0.0
		fmt.Println(rand.Intn(100)) //0-99   %100
	}

	fmt.Println(time.Now())
	fmt.Println(time.Now().Second())
	end := time.Now().Nanosecond()

	fmt.Println(end - start)
}

func BubbleSort(arr [10]int) [10]int {
	for i := 0; i < len(arr)-1; i++ {
		for j := 0; j < len(arr)-1-i; j++ {
			if arr[j] > arr[j+1] {
				arr[j], arr[j+1] = arr[j+1], arr[j]
			}
		}
	}

	return arr
}

func main0902() {
	var arr [10]int

	rand.Seed(time.Now().UnixNano())
	for i := 0; i < len(arr); i++ {
		arr[i] = rand.Intn(100) //0-99
	}

	arr = BubbleSort(arr)
	fmt.Println(arr)

}

10.引用

go不同文件之间的相互引用靠包来实现，总结下来就是：

1，文件夹就是包，文件夹名就是包名

2，同一文件夹（包）下的所有文件可以视为同一文件，也就是可以随意拆分或者合并为一个或多个 go 文件都没有影响，文件名对程序也没有影响

3，同一文件夹（包）下的所有文件， package name 必须一致。

4，如果要使用其他文件夹（包）下的资源，使用 import 导包， import 导包的路径是相对于 gopath/src 或者 gopath/pkg的相对路径

同目录如果引用报错：

GoLand的setting中的GOPATH和GOROOT都没有包含当前代码目录。

所以运行不起来。

解决：File==》Setting==》Go==》GOPATH==》增加当前代码目录。ok！

import如果引用报错：

改为：

import "./userinfo"