1.打包和工具链
1.1 包
所有 Go 语言的程序都会组织成若干组文件，每组文件被称为一个包。
1 2 3 4 5 6 7 8 9 10 | net/http/ cgi/ cookiejar/ testdata/ fcgi/ httptest/ httputil/ pprof/ testdata/在 http 目录下的所有文件都属于 http 包 |
所有的.go 文件，除了空行和注释，都应该在第一行声明自己所属的包。每个包都在一个单 独的目录里。不能把多个包放到同一个目录中，也不能把同一个包的文件分拆到多个不同目录中。 这意味着，同一个目录下的所有.go 文件必须声明同一个包名。
在 Go 语言里，命名为 main 的包具有特殊的含义。所有用 Go 语言编译的可执行程序都必须有一个名叫 main 的包。
1.2 导入
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | import ( "fmt" "strings")编译器先查找$GOROOT下的包,然后查找$GOPATH下的包1.推荐所有自定义包不放在$GOROOT下,该目录下一般是标准库,自定义包放在$GOPATH下,如果升级go版本,直接替换/usr/local/go相关文件,而不用重新替换自定义包2.go语言中字符串使用双引号"",注意与Python习惯区别go支持远程导入,如果import内的包名是一个地址,如"github.com/spf13/viper",在go run之前使用go get命令,程序会下载对应的包的$GOPATH的包目录下(该功能需要git支持)命名导入和未使用包标注import { myfmt "mylib/fmt" //重命名包名,在有多个包重名的情况下使用,同Python中的import package as pkg _ "fmt" //go语言不允许导入包而不使用,所以用下划线标注没有使用的包,实际不会导入} |
1.3 go工具介绍
- go build file.go //编译文件
- go clean file.go //删除编译生成的可执行文件
- go vet file.go //检查常见错误Printf类型匹配错误的参数,定义函数时方法签名错误,错误结构变量等
- go fmt file.go //自动整理文件格式,对齐
- go doc pkg //在终端查看包相关的文档
- godoc -http=:80 //启动一个go文档web服务器,如果开发人员按照godoc规则写代码,能自动包含在文档中
2.数组、切片和映射
2.1 数组
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 | // 声明一个包含5个元素的整型数组// 一旦声明，数组里存储的数据类型和数组长度就都不能改变var array [5]int //数组默认值为0array := [5]int{10, 20, 30, 40, 50}array := [...]int{10, 20, 30, 40, 50}array := [5]int{1: 10, 2: 20} //指定索引为1元素为10,索引为2元素为20// 声明包含 5 个元素的指向整数的数组// 用整型指针初始化索引为 0 和 1 的数组元素array := [5]*int{0: new(int), 1: new(int)}*array[0] = 10 // 为索引为0的元素赋值var array_ [5]intarray_ = array// 数组变量的类型包括数组长度和每个元素的类型。只有这两部分都相同的数组，才是类型相 同的数组，才能互相赋值// 声明一个二维整型数组，两个维度分别存储 4 个元素和 2 个元素var array [4][2]int// 使用数组字面量来声明并初始化一个二维整型数组array := [4][2]int{{10, 11}, {20, 21}, {30, 31}, {40, 41}}// 声明并初始化外层数组中索引为 1 个和 3 的元素array := [4][2]int{1: {20, 21}, 3: {40, 41}}// 声明并初始化外层数组和内层数组的单个元素array := [4][2]int{1: {0: 20}, 3: {1: 41}}// 声明一个需要 8 MB 的数组var array [1e6]int// 将数组传递给函数foo foo(array)//函数 foo 接受一个 100 万个整型值的数组func foo(array [1e6]int){ ... }每次函数 foo 被调用时，必须在栈上分配 8 MB 的内存。之后，整个数组的值（8 MB 的内 存）被复制到刚分配的内存里。虽然 Go 语言自己会处理这个复制操作，不过还有一种更好且更 有效的方法来处理这个操作。可以只传入指向数组的指针，这样只需要复制 8 字节的数据而不是 8 MB 的内存数据到栈上，优化如下// 分配一个需要 8 MB 的数组var array [1e6]int// 将数组的地址传递给函数foo foo(&array)// 函数 foo 接受一个指向 100 万个整型值的数组的指针func foo(array *[1e6]int){ ... }这个操作会更有效地利用内存，性能也更好。不过要意识到，因为现在传递的是指针， 所以如果改变指针指向的值，会改变共享的内存。使用切片能更好地处理这类共 享问题。 |
2.2 切片
切片是一个很小的对象，对底层数组进行了抽象，并提供相关的操作方法
切片有三个字段的数据结构：指向底层数组的指针、切片访问的元素的个数（即长度）和切片允许增长 到的元素个数（即容量）
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | // 创建一个字符串切片// 其长度和容量都是 5 个元素slice := make([]string, 5)// 创建一个整型切片// 其长度为 3 个元素，容量为 5 个元素，容量小于长度的切片会编译出错slice := make([]int, 3, 5)slice := []int{10, 20, 30}// 使用空字符串初始化第 100 个元素slice := []string{99: ""}// 创建 nil 整型切片var slice []intslice := make([]int, 0)slice := []int{}<strong>如果在[]运算符里指定了一个值，那么创建的就是数组而不是切片。只有不指定值 的时候，才会创建切片</strong> |
切片的使用
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 | // 其长度和容量都是 5 个元素slice := []int{10, 20, 30, 40, 50}// 其长度为 2 个元素,容量为 4 个元素,该切片不能看见底层数组第0号元素newSlice := slice[1:3]// 使用原有的容量来分配一个新元素// 将新元素赋值为 60newSlice = append(newSlice, 60)因为 newSlice 在底层数组里还有额外的容量可用，append 操作将可用的元素合并到切片 的长度，并对其进行赋值。由于和原始的 slice 共享同一个底层数组，slice 中索引为 3 的元 素的值也被改动了如果切片的底层数组没有足够的可用容量，append 函数会创建一个新的底层数组，将被引用的现有的值复制到新数组里，再追加新的值综上：创建切片的时候尽量使长度和容量一致，如果增加append新值是新开一个底层数组，而不是直接修改e.g: source := []int{0, 1, 2, 3} slice1 := source[0:3] fmt.Println(slice1) // [0 1 2] slice2 := append(slice1, 100) slice2[0] = 99 fmt.Println(slice1) fmt.Println(slice2) // [99 1 2] // [99 1 2 100]迭代切片slice := []int{10, 20, 30, 40}// 迭代每一个元素，并显示其值for index, value := range slice { fmt.Printf("Index: %d Value: %d
", index, value)}如果需要忽略index值，使用下划线占位当迭代切片时，关键字 range 会返回两个值。第一个值是当前迭代到的索引位置，第二个 值是该位置对应元素值的一份副本slice := []int{10, 20, 30, 40}for index, value := range slice { // 输出值和地址 fmt.Printf("Value: %d Value-Addr: %X ElemAddr: %X
", value, &value, &slice[index])}//第二种迭代方式for index := 0; index < len(slice); index++ { fmt.Printf("Index: %d Value: %d
", index, slice[index])}关键字 range 总是会从切片头部开始迭代。如果想对迭代做更多的控制，依旧可以使用传 统的 for 循环 |
多维切片
1 2 3 4 | // 创建一个整型切片的切片slice := [][]int{{10}, {100, 200}}// 为第一个切片追加值为 20 的元素slice[0] = append(slice[0], 20 |
切片属于引用类型，在函数间传递开销很小
举例理解切片和底层数组
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | // 长度为3, 容量为5slice1 := make([]int, 3, 5) // 修改5为3,创建一个长度与容量一致的切片// 切片所有默认值都是0slice1[1] = 1slice1[2] = 2// 切片2与1共享一个底层数组slice2 := slice1[0:3]// 在切片2上面增加一个数据slice3 := append(slice2, 200)// 在切片1上面增加一个数据slice4 := append(slice1, 100)fmt.Println(slice1) // [0, 1, 2]fmt.Println(slice2) // [0, 1, 2]fmt.Println(slice3) // [0, 1, 2, 100]fmt.Println(slice4) // [0, 1, 2, 100] |
再次说明：内置函数 append 会首先使用可用容量。一旦没有可用容量，会分配一个 新的底层数组。这导致很容易忘记切片间正在共享同一个底层数组。一旦发生这种情况，对切片 进行修改，很可能会导致随机且奇怪的问题。对切片内容的修改会影响多个切片，却很难找到问 题的原因。
2.3 映射
映射是一个集合，可以使用类似处理数组和切片的方式迭代映射中的元素。但映射是无序的 集合，意味着没有办法预测键值对被返回的顺序。即便使用同样的顺序保存键值对，每次迭代映 射的时候顺序也可能不一样。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 | // 创建一个映射，键的类型是 string，值的类型是int dict := make(map[string]int)// 创建一个映射，键和值的类型都是 string// 使用两个键值对初始化映射dict := map[string]string{"a": "1", "b": "2"}// 重新赋值dict["a"]="3"// 删除delete(dict, "a")// 判断key是否存在value, exists := dict["a"]if exists{ fmt.Println(value)}// 使用ranged迭代for key, value := range dict{ fmt.Printf("Key: %s Value: %s
", key, value)}映射的键可以是任何值。这个值的类型可以是内置的类型，也可以是结构类型，只要这个值 可以使用==运算符做比较。切片、函数以及包含切片的结构类型这些类型由于具有引用语义， 不能作为映射的键，使用这些类型会造成编译错误e.g1:dict := map[[]string]int{}fmt.Println(dict)// # command-line-arguments// ./main.go:9:10: invalid map key type []stringdict := map[[3]string]int{}// map[]e.g2:func main() { // 创建一个映射, 字母与对应的10进制ascii码 dict := map[string]int{"a": 97, "b": 98, "c": 99} for key, value := range dict { fmt.Printf("key: %s Value: %s
", key, value) } removeDict(dict, "b") fmt.Println(dict)}func removeDict(OneDict map[string]int, key string) { delete(OneDict, key)}1.Print以ln结尾的是直接输出,类似Python的print,可以输出各种类型(包括自定义结构体)变量并换行,一行输出多个值使用逗号隔开;以f结尾的是结构化输出,类似c语言中的printf2.在函数间传递映射并不会制造出该映射的一个副本。实际上，当传递映射给一个函数，并对 这个映射做了修改时，所有对这个映射的引用都会察觉到这个修改。这个特性和切片类似，保证可以用很小的成本来复制映射 |
3.GO语言的类型系统
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | // user 在程序里定义一个用户类型// 属性的类型也可以是用户自定义类型,用法类似c语言结构体structtype user struct { name string email string ext int privileged bool}// 声明 user 类型的变量var bill user// 声明变量并赋值lisa := user{ name: "Lisa", email: "lisa@email.com", ext: 123, privileged: true,}// 顺序必须与声明一致lisa := user{"Lisa", "lisa@email.com", 123, true}// 声明一个新类型type Duration int64// int64 类型叫作 Duration 的基础类型。不过，虽然 int64 是基础 类型，Go 并不认为 Duration 和 int64 是同一种类型。这两个类型是完全不同的有区别的 类型。e.g1:var dur Durationdur = int64(1000)./main.go:12:6: cannot use int64(1000) (type int64) as type Duration in assignment |
e.g2:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 | // 这个示例程序展示如何声明,并使用方法package mainimport ( "fmt")// user 在程序里定义一个用户类型type user struct { name string email string}// notify 使用值接收者实现了一个方法func (u user) notify() { fmt.Printf("Sending User Email To %s<%s>
", u.name, u.email)}// changeEmail 使用指针接收者实现了一个方法// 这个方法使用指针接收者声明。这个接收者的类型是指向 user 类型值的指针，而不是 user 类型的值。当调用使用指针接收者声明的方法时，这个方法会共享调用方法时接收者所指向的值func (u *user) changeEmail(email string) { u.email = email}// main 是应用程序的入口func main() { // user 类型的值可以用来调用 // 使用值接收者声明的方法 bill := user{"Bill", "bill@email.com"} bill.notify() // 指向 user 类型值的指针也可以用来调用 // 使用值接收者声明的方法 lisa := &user{"Lisa", "lisa@email.com"} lisa.notify() //指针被解引用为值， 这样就符合了值接收者的要求。notify 操作的是一个副本，只不过这次操作的是 从 lisa 指针指向的值的副本。 // (*lisa).notify() // user 类型的值可以用来调用 // 使用指针接收者声明的方法 bill.changeEmail("bill@newdomain.com") bill.notify() //变量 bill，以及之后使用这个变量调用使用指针接收者声明的 changeEmail 方法。Go 语言再一次对值做了调整，使之符合函数的接收者,进行调用 // (&bill).changeEmail ("bill@newdomain.com") // 指向 user 类型值的指针可以用来调用 // 使用指针接收者声明的方法 lisa.changeEmail("lisa@newdomain.com") lisa.notify()}// Go 语言既允许使用值，也允许使用指针来调用方法，不必严格符合接收者的类型。 |