(三) Go的高级类型_1

指针

---

Go 具有指针。指针保存了变量的内存地址

类型 *T 是指向类型 T 的值的指针。其零值是 nil。

var p *int

　　& 符号会生成一个指向其作用对象的指针。

i := 42
p = &i

　　* 符号表示指针指向的地址上的值。

fmt.Println(*p) //通过指针 p 读取 i
*p = 21　　　　　//通过指针 p 设置 i

　　这也就是通常所说的 "间接引用" 或 "非直接引用"。

与 C 不同，Go 没有指针运算。

 

 

结构体

---

type My struct {
    Name string
}

一个结构体（struct）就是一个字段的结合。

（而 type 的 含义跟其字面意思相符。）

结构体字段使用点号来访问。

结构体指针

var pMy *My = &My{}
pMy.Name = "QuestionMark"

　　结构体字段可以通过结构体指针来访问。

　　通过指针简洁的访问是透明的。

结构体文法

pMy = &My{ Name : "QuestionMark" }
fmt.Println(pMy.Name)

　　结构体文法表示通过结构体字段的值作为列表来新分配一个结构体。

　　使用 Name：语法可以仅列出部分字段。（字段名的顺序无关。）

　　特殊的前缀 & 返回一个指向结构体的指针。

 

数组

---

 

类型 [n]T 是一个有 n 个类型为 T 的值的数组。

表达式

var a [10]int

　　定义变量 a 是一个有十个整数的数组。

数组的长度是其类型的一部分，因此数组不能改变大小。但可以用切片（slice）来代替。

 

slice

---

func main() {
    mySlice := make([]int, 0, 5)
    printSlice("mySlice", mySlice)
}

func printSlice(sliceName string, slice []int) {
    fmt.Printf(" %s, len = %d, cap = %d ", sliceName, len(slice), cap(slice))  
}

slice 只能由 make 创建

一个 slice 会指向一个序列的值，并且包含了长度信息。

[]T 是一个元素类型为 T 的 slice。

len(s) 返回 slice s 的长度。

cap(s) 返回 slice s 的容量。

slice 可以包含任意的类型，包括它自身

 

slice 切片操作

func main() {
    mySlice := []int{1,2,3,4,5,6,7,8,9}
    mySlice = mySlice[:5]
    mySlice = mySlice[1:]
    mySlice = mySlice[0:0]
    mySlice = mySlice[0:1]
}

　　slice 可以重新切片，创建一个新的 slice 值指向相同的数组。

　　表达式

　　　　s[ lo : hi ]　　表示从 lo 到 hi - 1 的 slice 元素，包括前端数据，不包括后端数据。因此

　　　　s[ lo : lo ]　　是空的，而

　　　　s[ lo : lo + 1]  有一个元素

 

构造 slice

　　前面说过 slice 是必须由 make 创建。这会分配一个全是零值的数组并且返回一个 slice 指向这个数组：　　

　　　　mySlice := make( []int, 5 )　　// len(mySlice) = 5

　　为了指定容量，可传递第三个参数到 make :

　　　　mySlice := make( []int, 0, 5 ) 　　　　   // len(mySlice) = 0 cap(mySlice) = 5
　　　　mySlice = mySlice[ : cap(mySlice) ]　　  // len(mySlice) = 5 cap(mySlice) = 5
　　　　mySlice = mySlice[ 1 : ]　　　　　　　 　　// len(mySlice) = 4, cap(mySlice) = 4

　　

nil slice

　　slice 的零值是 nil。

　　一个 nil 的 slice 的长度和容量是 0。

 

向 slice 添加元素

　　先 slice 的末尾添加元素是一种常见的操作，因此 Go 提供了一个内建函数 append。

　　　　func append( slice []T, values ...T) []T

　　append 的第一个参数 slice 是一个元素类型为 []T 的 slice，其余类型为 T 的值将会附加到该 slice 的末尾。

　　append 的结果是一个包含原 slice 所有元素加上新添加的元素的 slice。

　　如果 slice 的底层数组

　　太小，而不能容纳所有值时，会分配一个更大的数组。返回的 slice 会指向这个新分配的数组。

　　eg:

　　　　func main() {
	　　mySlice := make([]int, 0, 1)
	　　mySlice = append(mySlice, 1, 2)
	　　fmt.Println("myslice : len = ", len(mySlice), " cap = ", cap(mySlice))
	　　return
　　　　}

　　　　//执行结果
　　　　//myslice : len = 2 cap = 2

 

range

　　for 循环的 range 格式可以对 slice 或者 map 进行迭代循环

　　但使用 for 循环遍历一个 slice 时，每次迭代 range 将返回两个值。

　　　　第一个是当前下标（序号）。

　　　　第二个是该下标所对应 slice 元素的一个 拷贝。

　　　　func main() {
	　　mySlice := make([]int, 0, 1)
	　　mySlice = append(mySlice, 1, 2)
	　　for i, v := range mySlice {
	　　	fmt.Println("i = ", i, " v = ", v)
	　　}
	　　return
　　　　}

　　可以通过赋值给 _ 来忽略序号的值。

　　如果只需要索引值，去掉 " ,v " 的部分即可 

 

Map

---

 

type My struct {
	Name string
}

func main() {
	myMap := make(map[string]My)
	myMap["me"] = My{"QuestionMark"}
	fmt.Println(myMap)
	return
}

map 映射建到值。

map 在使用之前必须用 make 来创建；值为 nil 的 map 是空的，并且不能对其赋值。

map 的文法跟结构体文法相似，不过必须有键名。

　　若顶级类型只是一个类型名，你可以在文法的元素中省略他。

在 map m 中

　　插入或修改一个元素：

　　　　m[key] = elem

　　获得元素：

　　　　elem = m[key]

　　删除元素：

　　　　delete(m, key)

　　通过双赋值检测是否重复键

　　　　elem,ok = m[key] // 也可以用 "_" 代替 elem 只取键是否存在

如果 key 在 m 中， ok 为 true。否则， ok 为 false，并且 elem 是 map 的元素类型的零值。

同样的，当从 map 中读取某个不存在的键时，结果是 map 的元素类型的零值。

 

函数值

---

 

func Test(fun func()) {
	fun()
}

func main() {
	helloText := "Hello World"
	helloFun := func() {
		fmt.Println(helloText)
	}
	Test(helloFun)
	return
}

函数也是值。他们也和其他值一样可以传递，比如，函数值可以作为函数

Go函数可以是一个闭包。闭包是一个函数值。它应用了函数体之外的变量。

这个函数可以对这个应用的变量进行访问和赋值；也就是这个函数被绑定（bind）在这个变量上。