Go 入门 - Go中的复杂类型
主要内容来自中文版的官方教程Go语言之旅
目的为总结要点
指针
Go 拥有指针。指针保存了值的内存地址。
类型 *T 是指向 T 类型值的指针。其零值为 nil。
var p *int
& 操作符会生成一个指向其操作数的指针。
i := 42
p = &i
* 操作符表示指针指向的底层值。
fmt.Println(*p) // 通过指针 p 读取 i
*p = 21 // 通过指针 p 设置 i
这也就是通常所说的“间接引用”或“重定向”。
与 C 不同，Go 没有指针运算。
package main
import "fmt"
func main() {
i, j := 42, 2701
p := &i // point to i
fmt.Println(*p) // read i through the pointer
fmt.Println(p)
*p = 21 // set i through the pointer
fmt.Println(i) // see the new value of i
p = &j // point to j
*p = *p / 37 // divide j through the pointer
fmt.Println(j) // see the new value of j
}
// output
// 42
// 0xc420084010
// 21
// 73
结构体
结构体是一些变量的集合，可以用以下方式创建一个结构体。修改结构体可以采用.符号，指向结构体的指针也可以用同样的方法来访问。
package main
import "fmt"
type Vertex struct {
X int
Y int
}
func main() {
v := Vertex{1,2}
fmt.Println(v)
v.X = 4
fmt.Println(v)
p := &v
p.X = 8
fmt.Println(v)
}
//output {1 2} {4 2} {8 2}
结构体与结构体的指针都可以用以下的方法初始化
package main
import "fmt"
type Vertex struct {
X, Y int
}
var (
v1 = Vertex{1, 2} // has type Vertex
v2 = Vertex{X: 1} // Y:0 is implicit
v3 = Vertex{} // X:0 and Y:0
p = &Vertex{1, 2} // has type *Vertex
)
func main() {
fmt.Println(v1, p, v2, v3)
}
数组与切片
数组的声明也是从做到右的，以var开头的或者短声明
var a [2] string
var a [10] int
primes := [6]{2, 3, 5, 7}
切片
类型[]T表示一个元素类型为T的切片。切片通过两个下标界定a[low:high]，这种切片会选择一个半开区间，包含第一个元素但是排除最后一个元素。切片下界的默认值是0，上界的默认值是该切片的长度。这里注意，如果制定了长度，那么得到的就是数组，在Go中数组是作为值传递的，会耗费很多的内存。
package main
import "fmt"
func main() {
primes := [6]int{2, 3, 5, 7, 11, 13} // 这是一个数组
var s []int = primes[1:4] // 这是在声明一个切片
fmt.Println(s)
names := [4]string{
"John","Paul","George","Ringo",
} // 这是一个数组
fmt.Println(names)
a := names[0:2] // 这也是一个切片
b := names[1:3] // 这也是一个切片
fmt.Println(a, b) // output [John Pul] [Paul George]
b[0] = "XXX"
fmt.Println(a, b) // output [John XXX] [XXX George]
fmt.Println(names) // output [John XXX George Ringo]
}
一个切片本身是底层数组的引用，多个切片可以共享一个底层数组，在一个切片上的修改可以影响到底层数组，进而影响到所有切片
切片拥有 长度 和 容量。对于切片s，长度是切片的长度，可以用len(s)获得，容量是从切片的第一个元素开始数一直到底层数组的长度，可以用cap(s)获得。
从底层数组的视角来看，切片中有意义的量只有三个，分别是起始位置，长度和容量。其中长度和容量是反映在切片自身重点，起始位置是用于锚定切片在底层数组中的位置。一旦切片建立，那么底层数组在起始位置之前的部分就会被扔掉。
在做切片的时候，其实s[low: high]中的low就选择了在当前的底层数组中的起始位置，high选择了终止位置，进而定义了长度high-low。在简历切片之后，底层数组精简原底层数组中low到末尾的部分。
nil切片是切片长度和容量都为零，且没有底层数组的切片，例如它可以这样声明var s []int。其实在这个意义上，数组自身就是长度和容量相等的切片。
切片可以包含任何类型，甚至其他的切片(多维数组)
board := [][]string{
[]string{"_", "_", "_"},
[]string{"_", "_", "_"},
[]string{"_", "_", "_"},
}
用range遍历切片
package main
import "fmt"
var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}
func main() {
for i, v := range pow {
fmt.Printf("2**%d = %d\n", i, v)
}
for _, value := range pow {
fmt.Printf("%d\n", value)
}
for value, _ := range pow {
fmt.Printf("%d\n", value)
}
}
映射
映射将key映射到value。用make函数可以创建给定类型的映射，并将其初始化备用。
映射的零值为nil，需要注意的是nil既没有键，也不能添加键
package main
import "fmt"
type Vertex struct {
Lat, Long float64
}
var m map[string]Vertex
func main() {
m = make(map[string]Vertex)
m["Bell Labs"] = Vertex{
40.68433, -74.39967,
}
fmt.Println(m["Bell Labs"])
}
映射的文法和结构体类似，但是一定要有键名
package main
import "fmt"
type Vertex struct {
Lat, Long float64
}
var m = map[string]Vertex{
"Bell Labs": Vertex{
40.68433, -74.39967,
},
"Google": Vertex{
37.42202, -122.08408,
},
}
func main() {
fmt.Println(m)
}
映射可以用下标访问或修改元素
用delete函数删除元素
用双赋值可以检测某个键的是否存在
package main
import "fmt"
func main() {
m := make(map[string]int)
m["Answer"] = 42
fmt.Println("The value:", m["Answer"])
m["Answer"] = 48
fmt.Println("The value:", m["Answer"])
delete(m, "Answer")
fmt.Println("The value:", m["Answer"])
v, ok := m["Answer"]
fmt.Println("The value:", v, "Present?", ok) // ok 是是否存在的boolean值
}
函数值
函数本身也可以作为值，称为函数值，可以作为函数的参数或者返回值
package main
import (
"fmt"
"math"
)
func compute(fn func(float64, float64) float64) float64 {
return fn(3, 4)
}
func main() {
hypot := func(x, y float64) float64 {
return math.Sqrt(x*x + y*y)
}
fmt.Println(hypot(5, 12))
fmt.Println(compute(hypot))
fmt.Println(compute(math.Pow))
}
Go函数可以使一个闭包。闭包是一个函数值，它引用了函数体之内的变量。该函数可以访问并赋予其引用的变量的值。例如下面的例子中adder函数返回值为一个闭包。每个闭包都被绑定在各自的sum变量上。
package main
import "fmt"
func adder() func(int) int {
sum := 0 //这是闭包的函数体之外的变量，它也被绑定在闭包内了
return func(x int) int { //这是闭包
sum += x
return sum
}
}
func main() {
pos, neg := adder(), adder()
for i := 0; i < 10; i++ {
fmt.Println(
pos(i),
neg(-2*i),
)
}
}
make函数
用make函数创建切片(动态数组)，有两种用法
a := make([]int, 5) // 长度为5，容量默认为5
b := make([]int, 0, 5) // 长度为0， 容量为5
func make([]T, len, cap) []T
用make函数可以创建给定类型的映射，并将其初始化备用
