主要内容来自中文版的官方教程Go语言之旅
目的为总结要点
指针
Go 拥有指针。指针保存了值的内存地址。
类型 *T 是指向 T 类型值的指针。其零值为 nil。
var p *int& 操作符会生成一个指向其操作数的指针。
i := 42
p = &i* 操作符表示指针指向的底层值。
fmt.Println(*p) // 通过指针 p 读取 i
*p = 21 // 通过指针 p 设置 i这也就是通常所说的“间接引用”或“重定向”。
与 C 不同，Go 没有指针运算。
package mainimport "fmt"func main() {i, j := 42, 2701p := &i // point to ifmt.Println(*p) // read i through the pointerfmt.Println(p)*p = 21 // set i through the pointerfmt.Println(i) // see the new value of ip = &j // point to j*p = *p / 37 // divide j through the pointerfmt.Println(j) // see the new value of j
}
// output
// 42
// 0xc420084010
// 21
// 73结构体
结构体是一些变量的集合，可以用以下方式创建一个结构体。修改结构体可以采用.符号，指向结构体的指针也可以用同样的方法来访问。
package main
import "fmt"
type Vertex struct {X intY int
}
func main() {v := Vertex{1,2}fmt.Println(v)v.X = 4fmt.Println(v)p := &vp.X = 8fmt.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 Vertexv2 = Vertex{X: 1} // Y:0 is implicitv3 = Vertex{} // X:0 and Y:0p = &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 mainimport "fmt"func main() {m := make(map[string]int)m["Answer"] = 42fmt.Println("The value:", m["Answer"])m["Answer"] = 48fmt.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 mainimport ("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 mainimport "fmt"func adder() func(int) int {sum := 0 //这是闭包的函数体之外的变量，它也被绑定在闭包内了return func(x int) int { //这是闭包sum += xreturn 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， 容量为5func make([]T, len, cap) []T
用make函数可以创建给定类型的映射，并将其初始化备用