欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

深入解析Go语言编程中slice切片结构

程序员文章站 2022-04-29 13:04:47
数组转换成切片 复制代码 代码如下: a := [10]int{} fmt.println(a)  s1 := a[:10]  //取前10个...

数组转换成切片

复制代码 代码如下:

a := [10]int{}
fmt.println(a)
 s1 := a[:10]  //取前10个元素 [5:]取 5-最后的元素
 fmt.println(s1)

slice测试
复制代码 代码如下:

a := []byte{'a', 'b', 'c', 'd', 'e', 'f', 'h'}
sa := a[2:5]
fmt.println(string(sa))
sd1 := a[3:5]
fmt.println(string(sd1)) //看看效果

我们看到这样的是slice_a指向array_ori 其实是从c指向到k 我们用fmt.println(cap(slice_a)) 结果肯定不是3

深入解析Go语言编程中slice切片结构

自己动手试一下下边这个
 

复制代码 代码如下:
  
        a := []byte{'a', 'b', 'c', 'd', 'e', 'f', 'h'}
 sa := a[2:5]
fmt.println(string(sa))
 s := sa[1:3]
 fmt.println(string(s))
 s2 := sa[3:5]
 fmt.println(string(s2))

slice是指向底层的数组,如果多个slice指向同一个的时候,其中一个改变了,其他的都改变。试一下下边这个
 
复制代码 代码如下:

a := []int{1, 2, 3, 4, 5}
s1 := a[2:5]
s2 := a[1:3]
fmt.println(s1, s2)
s1[0] = 9
fmt.println(s1, s2)

切片是引用类型,即如果赋值切片给另一个切片,它们都指向同一底层数组。例如,如果某函数取切片参量,对其元素的改动会显现在调用者中,类似于传递一个底层数组的指针。因此 read 函数可以接受切片参量,而不需指针和计数;切片的长度决定了可读数据的上限。这里是 os 包的 file 型的 read 方法的签名:

复制代码 代码如下:

  func (file *file) read(buf []byte) (n int, err os.error)

此方法返回读入字节数和可能的错误值。要读入一个大的缓冲 b 的首32字节, 切片(动词)缓冲。
复制代码 代码如下:

      n, err := f.read(buf[0:32])

这种切片常用且高效。实际上,先不管效率,此片段也可读缓冲的首32字节。
复制代码 代码如下:

      var n int
      var err os.error
      for i := 0; i < 32; i++ {
          nbytes, e := f.read(buf[i:i+1])  // read one byte.
          if nbytes == 0 || e != nil {
              err = e
              break
          }
          n += nbytes
      }

只要还在底层数组的限制内,切片的长度可以改变,只需赋值自己。切片的容量,可用内部函数 cap 取得,给出此切片可用的最大长度。下面的函数给切片添值。如果数据超过容量,切片重新分配,返回结果切片。此函数利用了 len 和 cap 对 nil 切片合法、返回0的事实。


apppend的用法
 

复制代码 代码如下:

a := make([]int, 3, 6)
 fmt.printf("%p", a)
 a = append(a, 1, 2, 3)
 fmt.printf("%v %p\n", a, a)
 a = append(a, 1, 2, 3)
 fmt.printf("%v %p\n", a, a)

我们必须返回切片,因为尽管 append 可以改变 slice 的元素, 切片自身(持有指针、长度和容量的运行态数据结构)是值传递的。添加切片的主意很有用,因此由内置函数 append 实现。
复制代码 代码如下:

  func append(slice, data[]byte) []byte {
      l := len(slice)
      if l + len(data) > cap(slice) {  // reallocate
          // allocate double what's needed, for future growth.
          newslice := make([]byte, (l+len(data))*2)
          // copy data (could use bytes.copy()).
          for i, c := range slice {
              newslice[i] = c
          }
          slice = newslice
      }
      slice = slice[0:l+len(data)]
      for i, c := range data {
          slice[l+i] = c
      }
      return slice
  }

当slice中append追加的元素超过了指向的容量,就会重新指向一个新的底层数组,所以一个底层数组的改变,不会带动其他的改变,试一下下边的代码

复制代码 代码如下:

a := []int{1, 2, 3, 4, 5}
s1 := a[2:5]
s2 := a[1:3]
fmt.println(s1, s2)
s2 = append(s2, 1, 2, 2, 3, 3, 4, 5)
s1[0] = 9
fmt.println(s1, s2)

copy
这是一个拷贝的函数,下边的代码是从s2拷贝到s1然后我们会看到结果是[7 8 9 4 5]
如果是copy(s2,s1) 我们看到的结果是[1 2 3]
 
复制代码 代码如下:

s1 := []int{1, 2, 3, 4, 5}
s2 := []int{7, 8, 9}
copy(s1, s2)
fmt.println(s1)