Go基础知识（一）

一、配置get源镜像

go env -w GO111MODULE=on
go env -w GOPROXY=https://goproxy.cn,direct

二、命令行执行go文件

2.1 源码:demo.go

package main //必须有一个main包import "fmt" // 导入包，必须使用func main() {fmt.Println("hello word")
}

2.2 生成exe方式运行

生成demo.exe

go build demo.go

demo.exe

2.3 直接运行

go run demo.go

三、变量的使用

声明方法：var

3.1 单重赋值

package mainimport "fmt"func main() {// 声明一个变量a,其类型为整型,默认为0var a inta = 10 // 给a赋值fmt.Println(a)// 声明多个相同类型变量var b, c intb = 20c = 30fmt.Println(b, c)// 声明多个不同类型的变量var (x inty float64)x = 100y = 3.14fmt.Println(x, y)// 自动推导类型(只能声明一次，不能再写成 d := 50,可以正常 d = 50)，声明一个变量d,并且赋值40d := 40fmt.Println(d)
}

3.2 多重赋值

package mainimport "fmt"func main() {// 多重赋值a, b, c := 10, 20, 30fmt.Println(a, b, c)
}

3.3 匿名变量

package mainimport "fmt"// 定义一个测试函数
func test() (a, b, c int) {return 1, 2, 3
}func main() {// 多重赋值d, e, f := 10, 20, 30fmt.Println(d, e, f)// _ 匿名变量   例如：调用test返回的3个值中的第二个值，重新给e赋值_, e, _ = test()fmt.Println(d, e, f)
}

四、常量的使用

package mainimport "fmt"func main() {const a = 10 // 声明一个常量a，其值为10a = 20 // 常量不能改变，故不能重新赋值，会出现：cannot assign to a (declared const)的错误fmt.Println(a)
}

五、iota枚举

package mainimport "fmt"func main() {// 1、iota常量自动生成器，每隔一行，自动累加1// 2、iota给常量赋值使用const (a = iotab = iotac = iota)fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c) // a = 0, b = 1, c = 2// 3、iota遇到const，重置为0const d = iotafmt.Printf("d = %d\n", d) // d = 0// 4、可以只写一个iotaconst (a1 = iotab1c1)fmt.Printf("a1 = %d, b1 = %d, c1 = %d\n", a1, b1, c1) // a1 = 0, b1 = 1, c1 = 2// 5、如果是同一行，值都一样const (i          = iotaj1, j2, j3 = iota, iota, iotak          = iota)fmt.Printf("i = %d, j1 = %d, j2 = %d, j3 = %d, k = %d\n", i, j1, j2, j3, k) // i = 0, j1 = 1, j2 = 1, j3 = 1, k = 2}

六、函数

package mainimport "fmt"func foo1(a string, b int) int {fmt.Println("a = ", a)fmt.Println("b = ", b)c := 100return c
}//返回多个返回值，匿名的
func foo2(a string, b int) (int, int) {fmt.Println("a = ", a)fmt.Println("b = ", b)return 666, 777
}//返回多个返回值， 有形参名称的
func foo3(a string, b int) (r1 int, r2 int) {fmt.Println("---- foo3 ----")fmt.Println("a = ", a)fmt.Println("b = ", b)//r1 r2 属于foo3的形参，  初始化默认的值是0//r1 r2 作用域空间 是foo3 整个函数体的{}空间fmt.Println("r1 = ", r1)fmt.Println("r2 = ", r2)//给有名称的返回值变量赋值r1 = 1000r2 = 2000return
}func foo4(a string, b int) (r1, r2 int) {fmt.Println("---- foo4 ----")fmt.Println("a = ", a)fmt.Println("b = ", b)//给有名称的返回值变量赋值r1 = 1000r2 = 2000return
}func main() {c := foo1("abc", 555)fmt.Println("c = ", c)ret1, ret2 := foo2("haha", 999)fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)ret1, ret2 = foo3("foo3", 333)fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)ret1, ret2 = foo4("foo4", 444)fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)
}

七、指针

7.1 值传递

package mainimport "fmt"func swap(a int ,b int) {var temp inttemp = aa = bb = temp
}func main() {var a int = 10var b int = 20swap(a, b)fmt.Println("a = ", a, " b = ", b)  // a =  10  b =  20
}

7.2 内存地址传递

package mainimport "fmt"func swap(pa *int, pb *int) {var temp inttemp = *pa //temp = main::a*pa = *pb  // main::a = main::b*pb = temp // main::b = temp
}func main() {var a int = 10var b int = 20swap(&a, &b)fmt.Println("a = ", a, " b = ", b) // a=20  b=10
}

八、defer用法

8.1 defer执行顺序:先进后出

package mainimport ("fmt"
)func func1() {fmt.Println("A")}
func func2() {fmt.Println("B")}
func func3() {fmt.Println("C")}func main() {defer func1()defer func2()defer func3()
}

8.2 defer和return执行顺序：return先执行，defer后执行

package mainimport ("fmt"
)func func1() int {fmt.Println("A")return 0}
func func2() int {fmt.Println("B")return 0
}func test() int {defer func1()return func2()
}func main()  {test()
}

九、数组和动态数组（slice）

9.1 固定长度数组（值拷贝）

package mainimport "fmt"func main()  {// 固定长度数组var myArray1 [10]int // 默认值为0for i :=0; i< len(myArray1); i++ {fmt.Print(myArray1[i]) // 0000000000}
}

package mainimport "fmt"func main() {// 固定长度数组myArray1 := [10]int{1, 2, 3, 4, 5}for index, value := range myArray1 {fmt.Println("index", index, "value:", value)}
}

9.2 动态数组（内存地址传递）

package mainimport "fmt"func printArray(myArray [] int)  {// 声明一个动态数组 []不指定长度就是动态数组for _, value :=range myArray{// _代表匿名变量不引用fmt.Println("value",value)}myArray[0] = 1000
}func main() {// 固定长度数组myArray1 := []int{1, 2, 3, 4, 5}printArray(myArray1)fmt.Println(myArray1)
}

9.3 slice 4种声明方法

package mainimport "fmt"func main() {//声明slice1是一个切片，并且初始化，默认值是1，2，3。 长度len是3//slice1 := []int{1, 2, 3}//声明slice1是一个切片，但是并没有给slice分配空间var slice1 []int//slice1 = make([]int, 3) //开辟3个空间 ，默认值是0//声明slice1是一个切片，同时给slice分配空间，3个空间，初始化值是0//var slice1 []int = make([]int, 3)//声明slice1是一个切片，同时给slice分配空间，3个空间，初始化值是0, 通过:=推导出slice是一个切片//slice1 := make([]int, 3)fmt.Printf("len = %d, slice = %v\n", len(slice1), slice1)//判断一个silce是否为0if slice1 == nil {fmt.Println("slice1 是一个空切片")} else {fmt.Println("slice1 是有空间的")}
}

9.4 slice切片追加

package mainimport "fmt"func main() {var numbers = make([]int, 3, 5)fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)//向numbers切片追加一个元素1, numbers len = 4， [0,0,0,1], cap = 5numbers = append(numbers, 1)fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)//向numbers切片追加一个元素2, numbers len = 5， [0,0,0,1,2], cap = 5numbers = append(numbers, 2)fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)//向一个容量cap已经满的slice 追加元素，numbers = append(numbers, 3)fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)fmt.Println("-=-------")var numbers2 = make([]int, 3)fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers2), cap(numbers2), numbers2)numbers2 = append(numbers2, 1)fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers2), cap(numbers2), numbers2)
}

9.5 slice切片截取

package mainimport "fmt"func main() {s := []int{1, 2, 3} //len = 3, cap = 3, [1,2,3]s1 := s[0:2] // [1, 2]fmt.Println(s1)s1[0] = 100fmt.Println(s)fmt.Println(s1)//copy 可以将底层数组的slice一起进行拷贝s2 := make([]int, 3) //s2 = [0,0,0]//将s中的值 依次拷贝到s2中copy(s2, s)fmt.Println(s2)
}

十、map三种定义方式

package mainimport "fmt"func main() {//===> 第一种声明方式//声明myMap1是一种map类型 key是string， value是stringvar myMap1 map[string]stringif myMap1 == nil {fmt.Println("myMap1 是一个空map")}//在使用map前， 需要先用make给map分配数据空间myMap1 = make(map[string]string, 10)myMap1["one"] = "java"myMap1["two"] = "c++"myMap1["three"] = "python"fmt.Println(myMap1)//===> 第二种声明方式myMap2 := make(map[int]string)myMap2[1] = "java"myMap2[2] = "c++"myMap2[3] = "python"fmt.Println(myMap2)//===> 第三种声明方式myMap3 := map[string]string{"one":   "php","two":   "c++","three": "python",}fmt.Println(myMap3)
}

十一、map使用方式

package mainimport "fmt"func printMap(cityMap map[string]string) {//cityMap 是一个引用传递for key, value := range cityMap {fmt.Println("key = ", key)fmt.Println("value = ", value)}
}func ChangeValue(cityMap map[string]string) {cityMap["England"] = "London"
}func main() {cityMap := make(map[string]string)//添加cityMap["China"] = "Beijing"cityMap["Japan"] = "Tokyo"cityMap["USA"] = "NewYork"//遍历printMap(cityMap)//删除delete(cityMap, "China")//修改cityMap["USA"] = "DC"ChangeValue(cityMap)fmt.Println("-------")//遍历printMap(cityMap)
}

十二、struct的使用

package mainimport "fmt"//声明一种行的数据类型 myint， 是int的一个别名
type myint int//定义一个结构体
type Book struct {title stringauth  string
}func changeBook(book Book) {//传递一个book的副本book.auth = "666"
}func changeBook2(book *Book) {//指针传递book.auth = "777"
}func main() {/*var a myint = 10fmt.Println("a = ", a)fmt.Printf("type of a = %T\n", a)*/var book1 Bookbook1.title = "Golang"book1.auth = "zhang3"fmt.Printf("%v\n", book1)changeBook(book1)fmt.Printf("%v\n", book1)changeBook2(&book1)fmt.Printf("%v\n", book1)
}