数组

固定长度，不如slice灵活，go中很少直接使用数组。

数组是值传递，不能通过修改数组类型的参数来修改这个数组的值。

package main

import "fmt"

func main() {
    x := [3]int{1, 2, 3}

    func(arr [3]int) {
        arr[0] = 7
        fmt.Println(arr)
    }(x)

    fmt.Println(x)
}
[7 2 3]
[1 2 3]
q := [...]int{1,2,3}
如果数组长度位置是省略号，则数组长度由实际插入决定

slice

• 变长序列。写法是[]T，T代表类型。
• 前边整理过的s[m:n] s[m:] s[:n] s[:]
• 跟数组一样，切片包括一个执行第一个值的指针，所以复制是就是生成一个别名的指针，指向第一个值。
• 切片反转
• 不能通过== 判断两个切片是否相同，但是可以通过bytes.Equal函数判断两个字节型slice是否相容（[]byte），但是对于其他类型的slice必须自己展开比较。
• 判断为空;

len(s)==0

• 用内置的make函数创建一个指定元素类型、长度和容量的slice。容量部分可以忽略，容量将等于长度。

make([]T,len)
make([]T,len,cap)   //类似  make([]T,cap)[:len]

这段看不懂 在底层，make创建了一个匿名的数组变量，然后返回一个slice；只有通过返回的slice才能用底层匿名的数组变量。在第一中语言中，slice是整个数组的view。在第二种语句中，slice只引用了底层数组的前len个元素，但是容量包含整个的数组。额外的元素是留给未来的增长用的。

append函数

用于向slice中追加元素

var runes []rune
for _, r:=range "hello, 世界"{
    runes = append(runes, r)
}
fmt.Printf("%q\n", runes)     //"['h' 'e' 'l' 'l' 'o' ',' ' ' '世' '界']"

在循环中使用append构建一个由9个rune字符组成的slice。 - cap（）返回的是数组切片分配的空间大小，可以有预留。

my := make([]int, 5, 10)
cap(my)返回的是10，make生成5个初始化值的my切片。

• copy(a,b)复制切片（有返回值，返回的是成功复制的元素个数），从b复制到a
• appendInt函数分配时，容量大于切片的容量会重新分配内存，*2。容量够用就不会。
• append可以追加多个元素甚至可以是一个切片。

slice内存技巧

旋转，反转，修改元素。 - 返回不含空字符串的列表nonempty函数

func nonempty(strings []string) []string {
    i := 0
    for _, s := range strings {
        if s != "" {
            strings[i] = s
            i++
        }
    }
    return strings[:i]
}

• 一个slice可以模拟一个stack。

stack = append(stack, v)

• 要删除slice中的某个元素但是保存原有的元素顺序，可以通过内置的copy函数将后边的子slice向前移动一位完成。

func remove(slice []int, i int) []int {
    copy(slice[i:], slice[i+1:])
    return slice[:len(slice)-1]
}
func main() {
    s := []int{5,6,7,8,9}
    fmt.Println(remove(s, 2))   //"[5 6 8 9]"
}

• 改写reverse函数，用数组指针代替slice
• 给函数传递数组，传递的只是数组的拷贝，问不是他的指针

package main

import "fmt"

func reverse(s *[5]int) {
    for i, j := 0, len(s)-1; i < j ; i, j = i+1, j-1 {
        (*s)[i], (*s)[j] = (*s)[j], (*s)[i]
    }
}

func main() {
    s := [5]int{1,2,3,4,5}
    reverse(&s)
    fmt.Println(s)
}

• 编写一个rotate函数，通过一次循环完成旋转。

package main

import "fmt"

func rotate(s []int, x int) []int{
    a := make([]int, 5, 10)
    for i := 0; i < len(s); i++ {
        a[i] =  s[(i+x)%5]
    }
    return a
}
func main() {
    my := []int{1,2,3,4,5}
    fmt.Println(rotate(my, 5))
//  fmt.Println(my)
}

• 消除[]string中相邻重复字符串

func StringNoRep(s []string) []string {
    for i := range s {
        if i == len(s)-1 {
            return s
        }
        if s[i] == s[i+1] {
            s = append(s[:i], s[i+1:]...)
        }
    }
    return s
}

map

在go语言中，一个MAP就是一个哈希表的引用，map类型可以写成map[K]V,key和value。map中所有的key可以使同一类型，所有的value可以是同一类型，但是key和value可以是不同类型。 内置的make函数可以创建一个map：

ages := make(map[string]int)   // mapping from strings to ints
ages["alice"] = 31
ages["chalie"] = 34

ager := map[string]int{
    "alice": 31,
    "charlie": 34
}

• 内置delete函数可以删除元素。

delete(ages, "alice")

• 因为map中的元素不是变量，所以不能进行取址操作。
• 可以用range风格的for循环遍历map的key/value
• map的迭代顺序是随机的，并且不同的哈希函数实现可能导致不同的遍历顺序。如果要按顺序遍历key/value对，必须显式地对key进行排序，可以使sort包的Strings函数符字符串slice进行排序。

for name, age := range ages{
    fmt.Pringf("%s\t%d\n", name, age)
}

• 不能向一个nil的map中存数据，在向map中存数据前必须先创建map
• 使用range遍历map数据类型时，两个变量分别对应map的第一个类型和第二个类型

package main

import "fmt"

func main()  {
    ages := make(map[string]int)   // mapping from strings to ints
    ages["alice"] = 31
    ages["chalie"] = 34
    for i,j := range ages {
        fmt.Println(i)
        fmt.Println(j)
    }
}
alice
31
chalie
34
Process finished with exit code 0

结构体

类似于类中的结构体，需要绑定到一个对象中。利用对象进行访问、复制、取址等工作。 - 参数顺序不同也是不同的结构体。

type Employee struct {
    ID        int
    Name      string
    Address   string
    DoB       time.Time
    Position  string
    Salary    int
    ManagerID int
}

var dilbert Employee

对成员取址，然后通过指针访问

position := &dilbert.Salary
*position = "Senior " + *position // promoted, for outsourcing to Elbonia

• S结构体中的成员不能是S类型的，但是可以是*S指针类型的，这样可以创建递归的数据结构，如链表和树结构。下边的代码是用数实现插入。

package main

import "fmt"

type tree struct {
    value       int
    left, right *tree
}//每个树的节点都是这个结构体递归出来的。
// Sort sorts values in place.
func Sort(values []int) {
    var root *tree
    for _, v := range values {
        root = add(root, v)
    }
    appendValues(values[:0], root)
}
// appendValues appends the elements of t to values in order
// and returns the resulting slice.
func appendValues(values []int, t *tree) []int {
    if t != nil {
        values = appendValues(values, t.left)
        values = append(values, t.value)
        values = appendValues(values, t.right)
    }
    return values
}

func add(t *tree, value int) *tree {
    if t == nil {
        // Equivalent to return &tree{value: value}.
        t = new(tree)
        t.value = value
        return t
    }
    if value < t.value {
        t.left = add(t.left, value)
    } else {
        t.right = add(t.right, value)
    }
    return t
}
func main() {
    my := []int{1,2,5,8,4,2,5,8}
    Sort(my)
    fmt.Println(my)
}

结构体面值

结构体值也可以用结构体面值表示，可以指定每个成员的值

type Point struct{x,y int}
p := Point{1, 2}

通常用第二种写法,顺序和其他成员的值不用考虑

p := Point{X: 1}

结构体可以做参数和返回值，可以对结构体中的成员做缩放等处理。 因为函数的参数都是值拷贝，所以要对结构体进行修改就要传入指针。

如果结构体的所有成员都是可比较的，那么这个结构体也是可比较的。可比较的结构体类型可以用于map的key类型。

结构体嵌入和匿名成员

两个有相似之处的结构体可以嵌入 比如轮胎和圆和点

type Point struct {
    X, Y int
}

type Circle struct {
    Center Point
    Radius int
}

type Wheel struct {
    Circle Circle
    Spokes int
}

但是访问会很繁琐比如 var w Wheel w.Circle.Center.X = 8 所以要有匿名成员

type Circle struct {
    Point
    Radius int
}

type Wheel struct {
    Circle
    Spokes int
}

各有一个匿名成员。特性是：类型必须是命名的类型或者是指向一个命名的类型的指针。 Point类型嵌入到了Circle结构体，Circle类型嵌入到了Wheel结构体 这样访问就变成了 var w Wheel x.X = 8 这样它们的字面值并没有简短的表示匿名成员的语法，一下语法不存在。

w = Wheel{8, 8, 5, 20}                       // compile error: unknown fields
w = Wheel{X: 8, Y: 8, Radius: 5, Spokes: 20} // compile error: unknown fields

可以用这样的语法

w = Wheel{Circle{Point{8, 8}, 5}, 20}
w.X = 5
fmt.Printf("%#v\n", w)

副词，代表打印时和go语言一样的语法结构

JSON

JSON是对JavaScript中各种类型的值——字符串、数字、布尔值和对象——Unicode文本编码。它可以用有效可读的方式表示第三章的基础数据类型和本章的数组、slice、结构体和map等聚合数据类型。 将GO中的一个结构体的切片转换成JSON的过程叫做编组，通过json.Marsha完成。生成的是很长的字符串，没缩进很难阅读。另一个json.Marshallndent函数是格式化的输出。

data, err := json.MarshalIndent(movies, "", "    ")
if err != nil {
    log.Fatalf("JSON marshaling failed: %s", err)
}
fmt.Printf("%s\n", data)