slice.md

---

---

1.基础

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

slice 的底层结构定义，指向底层数组的指针，当前长度 len 和当前 容量 的 cap。

var  s  = [5]int{1, 2, 3, 4, 5}
var  b  = s[2:3]
fmt.Println("b len()", len(b), "cap():", cap(b), "b:", b)
//长度：元素个数，不能超过slice的容量
//容量：从slice的起始元素到底层数组的最后一个元素的个数

2.copy 使用

//将第二slice元素拷贝到第一个slice
s1  := []int{1, 2, 3, 4, 5}
s2  := []int{7, 8}
copy(s1, s2)
fmt.Println("s1:", s1, "s1cap:", cap(s1), "s2:", s2)
//s1: [7 8 3 4 5] s1cap: 5 s2: [7 8]
copy(s2, s1)
fmt.Println("s1:", s1, "s2:", s2)
//s1: [1 2 3 4 5] s2: [1 2]

3.append

//将第二slice元素拷贝到第一个slice
s1  := []int{1, 2, 3, 4, 5}
s2  := []int{7, 8}
s1  =  append(s1, 6)
fmt.Println("t1:", s1)
// t1: [1 2 3 4 5 6]
s1  =  append(s1, s2...)
fmt.Println("t2:", s1)
// t2: [1 2 3 4 5 6 7 8]
var  s []rune
for  _, v  :=  range  "hello world" {
s  =  append(s, v)
}
fmt.Println("s:", s)
fmt.Printf("%q\n", s)
//重点：append 扩容，当长度<容量时，不需要扩容；反之，两倍长度扩容

4.slice比较

• reflect比较的方法，代码简单，性能低
• 循环遍历比较的方法，代码多，性能高

reflect比较法：

func StrSliceReflectEqual(a, b []string) bool {
return reflect.DeepEqual(a, b)
}

循环比较法：

func  main() {
s1  := []string{"a", "b"}
s2  := []string{"a", "c"}
ret  :=  StrSliceEqual(s1, s2)
fmt.Println(ret)
}
func  StrSliceEqual(a, b []string) bool {
//先比较长度是否相等,否则为false
if  len(a) !=  len(b) {
return  false
}
//再比较两个slice是否 都为nil或都不为nil,否则为false
if (a ==  nil) != (b ==  nil) {
return  false
}
//再比较对应索引处两个slice的元素是否相等,否则为false
for  i, v  :=  range a {
if v != b[i] {
return  false
}
}
return  true
}

5.slice 删除

index  :=  3  //删除元素的索引
var  s  = []int{1, 2, 3, 4, 5, 6}
s  =  append(s[:index], s[index+1:]...)
fmt.Println(s)
//[1 2 3 5 6]

reference:addr