场景1: 将切片b的元素追回到切片a之后: a= append(a,b...)

    1. a := []int{0,1,2}
    2. b := []int{3,4,5}
    3. a = append(a,b...) //三个点表示展开切片
    4. fmt.Println(a) //[0 1 2 3 4 5]

    场景2：复制切片a的元素到新的切片b上 

    1. a := []int{1,2,3,4,5}
    2. b := make([]int,len(a))
    3. copy(b,a)
    4. fmt.Println(b) //[1 2 3 4 5]

    场景3: 删除位于索引 i 的元素 (删除一个元素)a = append(a[:i], a[i+1:]...)

    1. a := []int{1,2,3,4,5,6,7}
    2. a = append(a[:2],a[2+1:]...)
    3. fmt.Println(a) //[1 2 4 5 6 7]

    a[:2]实际是元素3的位置，a[2+1:]索引3的值~end.再将这个索引后面的所有元素，追回到2上，达到删除效果。长度由7变为6


    场景4:** 切除切片a中从索引i至j位置的元素: a = append(a[:i],a[j:]...)

    1. a := []string{"jack","muss","kevin","tom","ken","Anna"}
    2.     a = append(a[:3],a[5:]...)
    3.     fmt.Println(a) //[jack muss kevin Anna]

    上面代码和场景3只相差了一个i+1,记住，这种方法，会删除给定的索引i至j-1的值 ，也就是删除的是一个片段，而不是一个元素

    场景5：为切片 a 扩展 j 个元素长度：a = append(a, make([]T, j)...)

    1. a := []int{1,2}//len = 2
    2. a = append(a,make([]int,10)...)
    3. fmt.Println(len(a)) //len = 12

    场景6: 在索引 i 的位置插入元素 x``：``a = append(a[:i], append([]T{x}, a[i:]...)...)

    1. a := []int{1,2,6,7}
    2. b := []int{3,4,5}
    3. //在切片a 的i位置插入切片b
    4. a = append(a[:2],append(b,a[2:]...)...) //先将要替换的片段临时append至b，再将b追加至a指定的位置
    5. fmt.Println(a) //[1,2,3,4,5,6,7]

    不过上面这种方法不高效，可以使用copy方法来实现这种插入

    1. a := []int{1,2,6,7}
    2. b := []int{3,4,5}
    3. //先将整个b追回到a的末尾
    4. a = append(a,b...) //1,2,6,7,3,4,5
    5. copy(a[2+len(b):],a[2:]) //拷贝6和7至5的位置,此时数组变成了1,2,6,7,3,6,7
    6. copy(a[2:],b)//再次将切片b拷贝至i为2的位置进行覆盖
    7. fmt.Println(a) //[1,2,3,4,5,6,7]

    所以针对这个方法，将它封装成一个函数

    1. func InsertStringSlice(dst []int, src []int, index int) (newSlice []int) {
    2.     dst = append(dst, src...)               //解包操作
    3.     copy(dst[index+len(src):], dst[index:]) //拷贝原index后所有的值至切片末尾
    4.     copy(dst[index:], src)                  //在指定Index插入切片进行覆盖原数据
    5.     newSlice = dst
    6.     return
    7. }

    这样做的用意是为了不让他产生临时切片。

    场景6：在索引 i 的位置插入长度为 j 的新切片：a = append(a[:i], append(make([]T, j), a[i:]...)...)

    1. a := []int{1,2,3,4,5,6}
    3. a = append(a[:2],append(make([]int,len(a)),a[2:]...)...)
    4. fmt.Println(a)//[1 2 0 0 0 0 0 0 3 4 5 6]
    5. //这种方法索引i本身+它后面的元素，会被放到新切片后面

    场景7:在索引 i 的位置插入切片 b 的所有元素：a = append(a[:i], append(b, a[i:]...)...)
    这种方法和我在场景5介绍的方法差不多

    1. a := []rune{'世','界','大','团','结','万','岁'}
    2. b := []rune{'人','民'}
    4. a = append(a[:2],append(b,a[2:]...)...)
    5. fmt.Println(string(a))  //世界人民大团结万岁

    场景8：取出位于切片 a 最末尾的元素x``：``x, a = a[len(a)-1], a[:len(a)-1]

    1. a := []rune{'无','产','阶','级','万','岁'}
    2. s,e :=a[len(a)-1],a[:len(a)-1]
    3. fmt.Println(string(s))  //岁
    4. fmt.Println(string(e))  //无产阶级万

    可以根据以上代码写一个反转切片的方法，每次循环时，交换索引 i与 len-1-i 的元素

    1. func ReverseString(s string) (r string)  {
    2.     run := []rune(s)//将s转为rune切片
    3.     for i :=0;i<len(run)/2;i++ {
    4.         run[len(run)-1-i],run[i] = run[i],run[len(run)-1-i]//交换
    5.     }
    6.     r = string(run)
    7.     return r
    8. }
    10. func main()  {
    11.     a := "世界人民大团结万岁"
    12.     str := ReverseString(a)
    13.     fmt.Println(str)
    14. }

    len(run) / 2是因为每次循环会交换两个值，所以要/2，而且交换也是要交换-1-i位置的元素，如果不加-i，则只会替换0与-1位置的值

    只需读取切片的最后一个元素：

    1. sl[len(sl)-1]

    要删除它：

    1. sl = sl[:len(sl)-1]