1、数组与Slice的区别

引用类型有：字典类型、通道类型 、函数类型等
值类型有：基础数据类型、结构体类型

2、Slice的长度、容量

func main() {
    s1 := make([]int, 5)
    fmt.Printf("len   s1: %d\n", len(s1))
    fmt.Printf("cap   s1: %d\n", cap(s1))
    fmt.Printf("value s1: %d\n", s1)
    s2 := make([]int, 5, 8)
    fmt.Printf("len   s2: %d\n", len(s2))
    fmt.Printf("cap   s2: %d\n", cap(s2))
    fmt.Printf("value s2: %d\n", s2)
    s3 := s2[1:]
    fmt.Printf("len   s3: %d\n", len(s3))
    fmt.Printf("cap   s3: %d\n", cap(s3))
    fmt.Printf("value s3: %d\n", s3)
    s4 := s2[1:3]
    fmt.Printf("len   s4: %d\n", len(s4))
    fmt.Printf("cap   s4: %d\n", cap(s4))
    fmt.Printf("value s4: %d\n", s4)
}
//打印的信息为
len   s1: 5
cap   s1: 5
value s1: [0 0 0 0 0]
len   s2: 5
cap   s2: 8
value s2: [0 0 0 0 0]
len   s3: 4
cap   s3: 7
value s3: [0 0 0 0]
len   s4: 2
cap   s4: 7
value s4: [0 0]

1、怎样估算切片容量的长度

当一个切片容量不够时，slice会进行扩容。扩容不会改变原来的slice，会生成一个更大的slice，然后把原有的元素和新元素一并拷贝到新slice中。

在一般情况下，新slice的容量会是原slice容量的2倍。当原slice的容量大于或1024时，Go语言将会以原容量的1.25倍作为新容量的基准

2、切片的底层数组什么时候会被替换

注意：slice的底层数组永远不会被替换，因为在slice扩容的时候一定会生成新的底层数组

3、Slice浅拷贝与深拷贝

func main() {
   s2 := make([]int, 5, 8)
   s3 := s2[1:]
   s4 := s2[0:5]
   //深拷贝需要在拷贝前申请空间
   s5:=make([]int,6,8)
   //s5拷贝s3
   copy(s5,s3)
   s3[1]=1
   fmt.Printf("value s2: %d\n", s2)
   fmt.Printf("value s3: %d\n", s3)
   fmt.Printf("value s4: %d\n", s4)
   fmt.Printf("value s5: %d\n", s5)
}
打印
value s2: [0 0 1 0 0]
value s3: [0 1 0 0]
value s4: [0 0 1 0 0]
value s5: [0 0 0 0 0 0]

s3、s4对s2进行浅拷贝它们公用一个底层数组，所以s3[1]位置的元素设置为1，s2、s3、s4 索引为1的元素全变为1，s5则不然。