类似python,不过python的是拷贝,go类似于一个view

  1. 基础

    类似python,不过python的是拷贝,go类似于一个view

    1
    2
    3
    4
    5
    6
    7
    8
    9
    //新建一个slice的方式
    //s := []Type{...v}
    //s := make([]Type[,len,cap])
    s1 := make([]int,10)
    fmt.Printf("%v %d %d\n",len(s1),cap(s1))//[0 0 0 0 0 0 0 0 0 0] 10 10
    s2 := make([]int,10,15)
    fmt.Printf("%v %d %d\n",len(s2),cap(s2))//[0 0 0 0 0 0 0 0 0 0] 10 15
    var s3 []int//s3 == nil
    fmt.Printf("%v %d %d\n", s3, len(s3), cap(s3))//[] 0 0

    slice可以向后扩展,不可向前扩展 eg:s6 s7
    s[]取值不可超过len(s) 向后扩展不可超过cap(s)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    func change(arr []int) {
    	arr[0]=777
    }

    func main() {
    	arr1 := [...]int{0,1,2,3,4,5,6,7,8,9}
    	s2 := arr1[2:8]
    	s3 := arr1[:8]
    	s4 := arr1[2:]
    	s5 := arr1[:]
    	s6 := arr1[2:5]
    	s7 := s6[2:7]

    	fmt.Println(arr1)//[0 1 2 3 4 5 6 7 8 9]
    	fmt.Println(s2)//[2 3 4 5 6 7]
    	fmt.Println(s3)//[0 1 2 3 4 5 6 7]
    	fmt.Println(s4)//[2 3 4 5 6 7 8 9]
    	fmt.Println(s4[3:])//[5 6 7 8 9]
    	fmt.Println(s5)//[0 1 2 3 4 5 6 7 8 9]
        fmt.Println(s6)//[2 3 4]
    	fmt.Println(s7)//[4 5 6 7 8]
    	change(arr1[:])
    	fmt.Println(arr1)//[777 1 2 3 4 5 6 7 8 9]
    }

  2. 相关函数

    1. append(slice,…v) slice
      slice是引用类型
      添加元素时,如果超过cap,会重新分配一个更大的底层数组

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      func printSlice(s []int) {
      	fmt.Printf("%v %d %d\n", s, len(s), cap(s))
      }

      var s []int
      for i := 0; i < 10; i++ {
      	printSlice(s)
      	s = append(s, i)
      }
      /*
      [] 0 0
      [0] 1 1
      [0 1] 2 2
      [0 1 2] 3 4
      [0 1 2 3] 4 4
      [0 1 2 3 4] 5 8
      [0 1 2 3 4 5] 6 8
      [0 1 2 3 4 5 6] 7 8
      [0 1 2 3 4 5 6 7] 8 8
      [0 1 2 3 4 5 6 7 8] 9 16
      每次cap扩容都是*2
      */

      如果是数组中间的切片,append会把后面的元素覆盖

      1
      2
      3
      4
      5
      6
      7
      8
      a := [...]int{0,1,2,3,4,5,6,7}
      s := a[2:5]
      fmt.Printf("%v %d %d\n", a, len(a), cap(a))//[0 1 2 3 4 5 6 7] 8 8
      printSlice(s)//[2 3 4] 3 6
      t := append(s,666)
      fmt.Printf("%v %d %d\n", a, len(a), cap(a))//[0 1 2 3 4 666 6 7] 8 8
      printSlice(s)//[2 3 4] 3 6
      printSlice(t)//[2 3 4 666] 4 6

    2. copy(dst,src) int
      把src这个slice中的值拷贝到dst里面去,int返回的是拷贝的值的数量

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      s4 := make([]int,10)
      s5 :=[]int{0,1,2,3,4,5}
      fmt.Println(copy(s4,s5))//6
      printSlice(s4)//[0 1 2 3 4 5 0 0 0 0] 10 10
      printSlice(s5)//[0 1 2 3 4 5] 6 6

      s6 := make([]int,4)
      s7 :=[]int{0,1,2,3,4,5}
      fmt.Println(copy(s6,s7))//4
      printSlice(s6)//[0 1 2 3] 4 4
      printSlice(s7)//[0 1 2 3 4 5] 6 6

    3. 删除元素

      官方没有实现,手动实现一个

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      //删除中间一段
      func delMiddleSlice(s []int, start, end int) []int {
      	return append(s[:start],s[end:]...)//...可转为可变参数
      }

      //删除头尾
      func delTrimSlice(s []int,start, end int) []int{
      	return append(s[start:end])
      }

      s7 :=[]int{0,1,2,3,4,5}
      printSlice(s7)//[0 1 2 3 4 5] 6 6
      s7 = delMiddleSlice(s7,2,4)
      printSlice(s7)//[0 1 4 5] 4 6
      printSlice(delTrimSlice(s7,1,4))//[1 4 5] 3 5