goLang笔记+beego框架

# goLang笔记 初始安装之后 GOPATH: Go开发相关的环境变量如下： GOROOT：**GOROOT**就是**Go的安装目录**，（类似于java的JDK） GOPATH：**GOPATH**是我们的**工作空间**,保存go项目代码和第三方依赖包 GOPATH可以设置多个，其中，第一个将会是默认的包目录，使用 go get 下载的包都会在第一个path中的src目录下，使用 go install时，在哪个GOPATH中找到了这个包，就会在哪个GOPATH下的bin目录生成可执行文件 go在编写之后要运行: 以run file 的方式运行  以run directory 方式运行  但是运行时会有下面的警告 go: go.mod file not found in current directory or any parent directory; see 'go help modules' 在go新版本时默认开启了go module,因此需要有go.mod来管理go代码中需要的依赖; 终端进入工作目录后 go mod init ,此时会生成一个go.mod文件  ## go mod 命令指南 所有go命令都内置了对模块的支持， 不只是“mod”。例如，日常的添加、删除、升级，并且应该使用“go get”来降级依赖。 `go mod init # 初始化go.mod` `go mod tidy # 更新依赖文件` `go mod download # 下载依赖文件` `go mod vendor # 将依赖转移至本地的vendor文件` `go mod edit # 手动修改依赖文件` `go mod graph # 打印依赖图` `go mod verify # 校验依赖` ### go mod 命令详解 `go mod init projectname` 以模块的方式初始化一个项目 `go mod tidy` 添加缺失的依赖,或者移除未被使用的依赖,一般在创建项目之后或者在添加新的依赖之后执行该命令; # go中的函数 go中的函数可以作为值进行传递,支持匿名函数和闭包 ## 定义函数 定义一个函数类型--作为统一的传递参数 ```go /* 定义一个函数类型 */ type funcDemo func(int) bool func isOdd(num int) bool { if num%2 == 0 { return true } else { return false } } func filterOdd(slice []int, f funcDemo) []int { var result []int for _, i2 := range slice { if f(i2) { result = append(result, i2) } } return result } func filterEven(slice []int, f funcDemo) []int { var result []int for _, i2 := range slice { if !f(i2) { result = append(result, i2) } } return result } func isEven(num int) bool { if num%2 != 0 { return true } else { return false } } func main() { demo := []int{1, 2, 3, 4, 5, 6, 7, 8, 9} odd := filterOdd(demo, isOdd) even := filterEven(demo, isEven) for _, i2 := range odd { fmt.Printf("%d 、", i2) } fmt.Println() for _, i2 := range even { fmt.Printf("%d 、", i2) } } ``` ## 匿名函数 匿名函数作为回调函数 ```go func visit(list []float64, f func(f float64) float64) { for _, value := range list { fmt.Println(f(value)) } } func sqrNum(num float64) float64 { return math.Sqrt(num) } func main() { list := []float64{1, 4, 9, 16, 25, 36} visit(list, sqrNum) } ``` 在定义时就调用匿名函数和将匿名函数赋值给变量 ```go func main11() { dt := func(data int) int { return data }(100) printData(dt) } func printData(s int) { fmt.Println(s) } ``` ## 闭包 闭包就是由函数和其相关的引用环境组合而成的实体~**函数+引用环境=闭包** 一个函数就是一个实例,而闭包在运行时可以有多个实例,不同的引用环境和相同的引用组合可以产生不同的的实例; ```go func main() { num := countEvenNum() for i := 0; i < 10; i++ { fmt.Println(num(i)) } fmt.Println("----------------------------") for i := 0; i < 10; i++ { fmt.Println(num(i)) } } func countEvenNum() func(int) int { var num = 0 return func(i int) int { if i%2 != 0 { num += i } return num } } ``` 闭包捕获了和他在同一作用域的其他变量和常量,所以闭包在任何地方被调用都会使用这些常量/变量,而不关心这些变量/常量已经超出作用域; ## 可变参数 可变参数~这点跟java一样--略 递归函数 ```go //使用递归函数实现 /** num + num-1 直到 num=1时停止 */ func DiG(num int) int { if num == 1 { return 1 } return num + DiG(num-1) } func main() { fmt.Println(DiG(10)) } ``` # go中的指针 > go中的指针最大的特点是:指针不能运算~即指针不能移动 **获取取地址 &** ~获取变量的地址 **获取取值 *** ~访问指针变量中指向地址的值 ## 声明指针/使用指针 ## 将基本数据类型的值作为函数参数,可以实行对传入数据的修改 ```go /* * i *int 指向int的指针 */ func ptrd(i *int) { *i = 90 } var s *int func main() { i := 100 fmt.Println(i) ptrd(&i) fmt.Println(i) //s指向i s = &i //空指针~nil if s != nil { fmt.Println(s) //取其值 fmt.Println(*s) } } ``` 指针数组 ```go func main() { str := []string{"h", "e", "l"} var ptr [3]string for i := 0; i < len(ptr); i++ { ptr[i] = str[i] } for _, value := range ptr { fmt.Printf("%T--->%v \n", value, value) } } ``` 指针的指针 ``` /* * 指针的指针 第一个指针存放的第二个指针的地址 第二个指针存放的变量的地址 */ func pointer() { var ptr *int var pptr **int fmt.Printf("%T \n", ptr) a := 2345 ptr = &a pptr = &ptr fmt.Println(ptr) fmt.Println(pptr) fmt.Println() fmt.Printf("指针变量--%d \n", *ptr) fmt.Printf("指针的指针--%d \n", *pptr) fmt.Printf("指针的指针的值--%d", **pptr) } func main() { pointer() } ``` go中slice map ,chan作为参数传递时都传的是指针 练习题: 1,使用递归实现n! ```go func DGJC(num int) int { if num == 1 { return 1 } return num * DGJC(num-1) } func main() { fmt.Println(DGJC(5)) } ``` 2,使用闭包函数实现斐波那契数列,并输出前十个 ```go //2,使用闭包函数实现斐波那契数列,并输出前十个 func FBNQ() func() int { var a int = 0 var b int = 1 return func() int { c := a a = b b = a + c return c } } func main() { f := FBNQ() for i := 0; i < 10; i++ { fmt.Println(f()) } } ``` # go中容器 **数组** ```go func numData() { //生明数组 var arr []int arr = []int{1, 2, 3, 4, 5, 7} //自动推断数组的长度 arrlist := [...]int{1, 2, 3, 4, 56, 0} fmt.Println(len(arrlist)) fmt.Println("------------------") for _, i2 := range arr { fmt.Println(i2) } fmt.Println(len(arr)) //将数组切分 arr2 := arr[2:3] fmt.Println(arr2) } ``` 多维数组 ```go func mutiNumData() { //一个多维数组 var arr [3][4]int arr = [3][4]int{ {1, 2}, {3, 4}, {5, 6, 7}, } fmt.Println(arr) fmt.println(arr[1][2])//访问方式 } ``` 三维数组,四维数组不在概述,一般很少用到 > 数组是值类型,在作为参数传递时,会将原数组复制一份分配给新变量,对新变量的修改不会影响到旧变量,而对于切片 map chan,由于传递的是地址,所以会影响到旧变量本身 ```go func mdata(a [10]int) { a[0] = 100 } func main() { var a [10]int for i := 9; i > 0; i-- { a[i] = i } mdata(a) fmt.