衍生类型，interface{} , map, [] ，struct等

一、map

map类似于java的hashmap，python的dict，php的hash array。

1.1 map的初始化

  m:=new(map[string]string) // m 是一个指针，指向m，fmt.Printf(m)，是指针地址
  m:=make(map[string]string) //m 是一个切片，m直接生成内存堆区，打印的是m整体的内容
  var m map[string]string // m 只是一个类型定义，但m没有申请内存堆，无法实现k，v赋值，必须make出切片后，才能放k，v数据
  var m = map[string]string{} // 和make的一样，{}表示初始化，当然可以在里面放初始化的数据

  var m = map[string]string{
    "name":"wangjian",
    "address": "bejing",
  }
  if m["sex"] == "male" {   //最好先判断是否存在key
  // if v, exist := m["ok"]; exist && v == "male" { //先判断，再判断
      // add todo 
  }

1.2 map的for

常规的for循环，可以用for k,v :=range m {}. 但在下面清空有一个坑注意：

  mm:=map[string]string{
    "key": "node",
    "ip" : "123.33.11.33",
    "time": "2018-12-31",
    }
  for _, v :=range mm {
        v += "_copy"
  }
  fmt.Println(mm)  //不改变mm的内容
  for k, _ :=range mm {
    mm[k] += "_copy"
  }
  fmt.Println(mm) //改变了mm的内容

著名的map[string]*struct 副本问题

  humans:=make(map[string]*human)
  names:=[]string{
    "wangjian",
    "chenrui",
    "heming",
  }
  l:=[]human{}
  address:=[]string {
    "beijing","wuhan","shanghai",
  }
  for i:=0 ;i<3 ;i++ {
    h:=human{
      names[i],
      20+i,
      address[i],
    }
    l = append(l, h)
  }
  for _, stu := range l {
    humans[stu.Name] = &stu  //传入的是同一个副本
  }
  fmt.Println(humans)
  for k,v:=range humans{
    fmt.Println(k,"=>",v.Name)
  }

结果：

map[heming:0xc0000621e0 wangjian:0xc0000621e0 chenrui:0xc0000621e0]
//执行地址一样，且每个内容都一样
wangjian => heming
chenrui => heming
heming => heming

1.3 函数的map参数

Go 中不存在引用传递，所有的参数传递都是值传递，而map是等同于指针类型的，所以在把map变量传递给函数时，函数对map的修改，也会实质改变map的值。

二、slice

slice类似于其他语言的数组（list，array），slice初始化和map一样，这里不在重复

2.1 slice结构

type slice struct {
    array unsafe.Pointer 
    len   int            
    cap   int            
}

除了Pointer数组外，len表示使用长度，cap是总容量，make([]int, len, cap)可以预申请 比较大的容量，这样可以减少容量拓展的消耗，前提是要用到。

2.2 cap和len

cap是计算切片容量，len是计算变量长度的，两者不一样。具体例子如下：

func main() {
    var nums =[]int{}
    for i:=1;i<=10;i++ {
        fmt.Println("cap(nums)", cap(nums), "len(nums)", len(nums))
        nums = append(nums,i)
    }
}

结果：

cap(nums) 0 len(nums) 0
cap(nums) 1 len(nums) 1
cap(nums) 2 len(nums) 2
cap(nums) 4 len(nums) 3
cap(nums) 4 len(nums) 4
cap(nums) 8 len(nums) 5
cap(nums) 8 len(nums) 6
cap(nums) 8 len(nums) 7
cap(nums) 8 len(nums) 8
cap(nums) 16 len(nums) 9

分析：cap是计算当前slice已分配的容量大小，采用的是预分配的伙伴算法（当容量满时，拓展分配一倍的容量）。

2.3 append函数

append是slice非常常用的函数，用于添加数据到slice中，但如果使用不好，会有下面的问题：

func addNum(nums []int) {
    nums = append(nums, 11)
    nums = append(nums, 12)
}

func main() {
    var nums =[]int{}
    for i:=1;i<=10;i++ {
        fmt.Printf("%p\n", nums)
        nums = append(nums,i)
    }
    fmt.Println(nums)
    addNum(nums)
    fmt.Println(nums)
}

预期是[1 2 3 4 5 6 7 8 9 10]， [1 2 3 4 5 6 7 8 9 10 11 12]，但实际结果是：

[1 2 3 4 5 6 7 8 9 10]
[1 2 3 4 5 6 7 8 9 10]

注意slice是值传递，修改一下：

func addNum(nums *[]int) {
    fmt.Printf("%p\n", nums)
    *nums = append(*nums, 11)
    fmt.Printf("%p\n", nums)
    *nums = append(*nums, 12)
}

func main() {
    var nums =[]int{}
    for i:=1;i<=10;i++ {
        fmt.Printf("%p\n", nums)
        nums = append(nums,i)
    }
    fmt.Println("============")
    fmt.Println(nums)
    addNum(&nums)
    fmt.Println(nums)
}

输出如下：

[1 2 3 4 5 6 7 8 9 10]
[1 2 3 4 5 6 7 8 9 10 11 12]

三、map和slice 的==比较

== 只能用于判断常规数据类型，无法使用用于slice和map判断，用于判断map和slice可以使用reflect.DeepEqual，这个函数用了递归来判断每层的k，v是否一致。

  a:=[]int{1,2,3,4,5}
  b:=[]int{1,2,3,4,5}
  if reflect.DeepEqual(a, b) {
    fmt.Println("true")
  }
  c:=map[string]string{
    "name":"wangjian",
    "age":"21",
  }
  d:=map[string]string{
    "name":"wangjian",
    "age":"21",
  }
  if reflect.DeepEqual(c, d) {
    fmt.Println("true")
  }

当然还有其他方式，比如转换成json，但小心有一些异常的bug，比如html编码，具体这个json问题，待后面在分析。