【转】Golang 切片与函数参数“陷阱”

最新推荐文章于 2024-05-20 20:54:27 发布
最新推荐文章于 2024-05-20 20:54:27 发布
阅读量333 收藏
点赞数
分类专栏： go 文章标签： golang
原文链接：https://studygolang.com/articles/9876
版权

转自这里

线性结构是计算机最常用的数据结构之一。无论是数组（arrary）还是链表（list），在编程中不可或缺。golang也有数组，不同于别的语言，golang还提供了切片（slice）。切片比数组有更好的灵活性，具有某些动态特性。然而切片又不像动态语言的列表（Python list）。不明白切片的基本实现，写程序的时候容易掉“坑”里。

slice参数

本来写一个堆排序，使用了golang的slice来做堆，可是发现在pop数据的时候，切片不改变。进而引发了golang函数切片的参数，是传值还是传引用呢？我们知道slice相比array是引用类型。那么直觉上告诉我们如果函数修改了参数的切片，那么外层的切片变量也会变啦。

func main() {

    slice := []int{0, 1, 2, 3}
    fmt.Printf("slice: %v slice addr %p \n", slice, &slice)

    ret := changeSlice(slice)
    fmt.Printf("slice: %v ret: %v slice addr %p \n", slice, &slice, ret)
}

func changeSlice(s []int) []int {
    s[1] = 111
    return s
}

结果和假设的一样：

slice: [0 1 2 3], slice addr: 0xc4200660c0 
slice: [0 111 2 3], ret: [0 111 2 3], slice addr: 0xc4200660c0

changeSlice函数修改了切片，变量 slice也跟着修改了。可是如果轻易就下结论，切片参数是按照引用传递，那么下面的现象就需要一种说法了：

func changeSlice(s []int) []int {
    fmt.Printf("func: %p \n", &s)
    s[1] = 111
    return s
}

我们在函数中打出参数 s 的地址，可以看见这个地址和main函数中的slice竟然不是同一个。为了了解这个，我们需要了解golang中的slice基本实现。

slice基本实现

Golang中的slice，是一个看似array却不是array的复合结构。切片顾名思义，就是数组切下来的一个片段。slice结构大致存储了三个部分，第一部分为指向底层数组的指针ptr，其次是切片的大小len和切片的容量cap：

      +--------+
      |        |
      |  ptr   |+------------+-------+-----------+
      |        |                     |           |
      +--------+                     |           |
      |        |                     |           |
      |        |                     |           |
      |  len 5 |                     |           |
      |        |                     |           |
      +--------+                     v           v
      |        |             +-----+-----+-----+-----+----+
      |        |             |     |     |     |     |    |
      |  cap 5 |     [5]int  |  0  |  1  |  2  |  3  | 4  |
      |        |             +-----+-----+-----+-----+----+
      +--------+



       slice := arr[1:4]             arr := [5]int{0,1,2,3,4}

有一个数组arr是一个包含五个int类型的结构，它的切片slice只是从其取了 1到3这几个数字。我们同样可以再生成一个切片 slice2 := arr[2:5], 所取的就是数组后面的连续块。他们共同使用arr作为底层的结构，可以看见共用了数字的第3，4个元素。修改其中任何一个，都能改变两个切片的值。

func main() {

    arr := [5]int{0, 1, 2, 3, 4}
    fmt.Println(arr)

    slice := arr[1:4]
    slice2 := arr[2:5]

    fmt.Printf("arr %v, slice1 %v, slice2 %v, %p %p %p\n", arr, slice, slice2, &arr, &slice, &slice2)

    fmt.Printf("arr[2]%p slice[1] %p slice2[0]%p\n", &arr[2], &slice[1], &slice2[0])

    arr[2] = 2222

    fmt.Printf("arr %v, slice1 %v, slice2 %v\n", arr, slice, slice2)


    slice[1] = 1111

    fmt.Printf("arr %v, slice1 %v, slice2 %v\n", arr, slice, slice2)

}

输出的值为：

[0 1 2 3 4]
arr [0 1 2 3 4], slice1 [1 2 3], slice2 [2 3 4], 0xc42006e0c0 0xc4200660c0 0xc4200660e0
arr[2]0xc42006e0d0 slice[1] 0xc42006e0d0 slice2[0]0xc42006e0d0
arr [0 1 2222 3 4], slice1 [1 2222 3], slice2 [2222 3 4]
arr [0 1 1111 3 4], slice1 [1 1111 3], slice2 [1111 3 4]

由此可见，数组的切片，只是从数组上切一段数据下来，不同的切片，其实是共享这些底层的数据数据。不过这些切片本身是不一样的对象，其内存地址都不一样。

从数组中切一块下来形成切片很好理解，有时候我们用make函数创建切片，实际上golang会在底层创建一个匿名的数组。如果从新的slice再切，那么新创建的两个切片都共享这个底层的匿名数组。

func main() {

    slice := make([]int, 5)
    for i:=0; i<len(slice);i++{
        slice[i] = i
    }
    fmt.Printf("slice %v \n", slice)

    slice2 := slice[1:4]
    fmt.Printf("slice %v, slice2 %v \n", slice, slice2)

    slice[1] = 1111
    fmt.Printf("slice %v, slice2 %v \n", slice, slice2)
}

输出如下：

slice [0 1 2 3 4] 
slice [0 1 2 3 4], slice2 [1 2 3] 
slice [0 1111 2 3 4], slice2 [1111 2 3]

slice的复制

既然slice的创建依赖于数组，有时候新生成的slice会修改，但是又不想修改原来的切片或者数组。此时就需要针对原来的切片进行复制了。

func main() {

    slice := []int{0, 1, 2, 3, 4}

    slice2 := slice[1:4]

    slice3 := make([]int, len(slice2))

    for i, e := range slice2 {
        slice3[i] = e
    }

    fmt.Printf("slice %v, slice3 %v \n", slice, slice3)

    slice[1] = 1111

    fmt.Printf("slice %v, slice3 %v \n", slice, slice3)
}

输出：

slice [0 1 2 3 4], slice3 [1 2 3] 
slice [0 1111 2 3 4], slice3 [1 2 3]

由此可见，新创建的slice3，不会因为slice和slice2的修改而改变slice3。复制很有用，因此golang实现了一个内建的函数copy， copy有两个参数，第一个参数是复制后的对象，第二个是复制前的数组切片对象。

func main() {

    slice := []int{0, 1, 2, 3, 4}
    slice2 := slice[1:4]

    slice4 := make([]int, len(slice2))

    copy(slice4, slice2)

    fmt.Printf("slice %v, slice4 %v \n", slice, slice4)
    slice[1] = 1111
    fmt.Printf("slice %v, slice4 %v \n", slice, slice4)
}

slice4是从slice2中copy生成，slice和slice4底层的匿名数组是不一样的。因此修改他们不会影响彼此。

slice 追加

append 简介

创建复制切片都是常用的操作，还有一个追加元素或者追加数组也是很常用的功能。golang提供了append函数用于给切片追加元素。append第一个参数为原切片，随后是一些可变参数，用于将要追加的元素或多个元素。

func main() {

    slice := make([]int, 1, 2)
    slice[0] = 111

    fmt.Printf("slice %v, slice addr %p, len %d, cap %d \n", slice, &slice, len(slice), cap(slice))

    slice = append(slice, 222)
    fmt.Printf("slice %v, slice addr %p, len %d, cap %d \n", slice, &slice, len(slice), cap(slice))

    slice = append(slice, 333)
    fmt.Printf("slice %v, slice addr %p, len %d, cap %d \n", slice, &slice, len(slice), cap(slice))

}

输出结果为：

slice [111], slice addr 0xc4200660c0, len 1, cap 2 
slice [111 222], slice addr 0xc4200660c0, len 2, cap 2 
slice [111 222 333], slice addr 0xc4200660c0, len 3, cap 4
切片容量

无论数组还是切片，都有长度限制。也就是追加切片的时候，如果元素正好在切片的容量范围内，直接在尾部追加一个元素即可。如果超出了最大容量，再追加元素就需要针对底层的数组进行复制和扩容操作了。

这里有一个切片容量的概念，从数组中切数据，切片的容量应该是切片的最后一个数据，和数组剩下元素的大小，再加上现有切片的大小。

数组 [0, 1, 2, 3, 4] 中，数组有5个元素。如果切片 s = [1, 2, 3]，那么3在数组的索引为3，也就是数组还剩最后一个元素的大小，加上s已经有3个元素，因此最后s的容量为 1 + 3 = 4。如果切片是
s1 = [4]，4的索引再数组中是最大的了，数组空余的元素为0，那么s1的容量为 0 + 1 = 1。具体如下表：

切片切片字面量数组剩下空间长度容量
s[1:3][1 2]224
s[1:1][]404
s[4:4][]101
s[4:5][4]011

尽管上面的第二个和第三个切片的长度一样，但是他们的容量不一样。容量与最终append的策略有关系。

append简单实现

我们已经知道，切片都依赖底层的数组结构，即使是直接创建的切片，也会生成一个匿名的数组。使用append时候，本质上是针对底层依赖的数组进行操作。如果切片的容量大于长度，给切片追加元素其实是修改底层数中，切片元素后面的元素。如果容量满了，就不能在原来的数组上修改，而是要创建一个新的数组，当然golang是通过创建一个新的切片实现的，因为新切片必然也有一个新的数组，并且这个数组的长度是原来的2倍，使用动态规划算法的简单实现。

func main() {

    arr := [3]int{0, 1, 2}

    slice := arr[1:2]

    fmt.Printf("arr %v len %d, slice %v  len %d, cap %d, \n", arr, len(arr), slice, len(slice), cap(slice))

    slice[0] = 333

    fmt.Printf("arr %v len %d, slice %v  len %d, cap %d, \n", arr, len(arr), slice, len(slice), cap(slice))

    slice = append(slice, 4444)

    fmt.Printf("arr %v len %d, slice %v  len %d, cap %d, \n", arr, len(arr), slice, len(slice), cap(slice))

    slice = append(slice, 5555)

    fmt.Printf("arr %v len %d, slice %v  len %d, cap %d, \n", arr, len(arr), slice, len(slice), cap(slice))

    slice[0] = 333

    fmt.Printf("arr %v len %d, slice %v  len %d, cap %d, \n", arr, len(arr), slice, len(slice), cap(slice))
}

输出：

arr [0 1 2] len 3, slice [1]  len 1, cap 2, 
arr [0 333 2] len 3, slice [333]  len 1, cap 2, 
arr [0 333 444] len 3, slice [333 444]  len 2, cap 2, 
arr [0 333 444] len 3, slice [333 444 555]  len 3, cap 4, 
arr [0 333 444] len 3, slice [333 444 555]  len 3, cap 4,
小于容量的append

重输出，我们来画一下这个动态过程的图示：

       +----+----+----+                           +----+----+----+                             +----+----+----+
       |    |    |    |                           |    |    |    |                             |    |    |    |
 arr   | 0  |  1 |  2 |                     arr   | 0  |333 | 2  |                       arr   | 0  |333 |444 |
       +----+----+----+                           +----+----+----+                             +----+----+----+
               ^                                          ^                                            ^    ^
               |                                          |                                            |    |
               |                                          |                                            |    |
               |                 slic0] = 333             |              slice = append(slice, 444)    +----+
               |               +----------------->        |                +---------------->          |
               |                                          |                                            |
            +--+--+----+----+                          +--+--+----+----+                            +--+--+----+----+
            |     |    |    |                          |     |    |    |                            |     |    |    |
            | p   | 1  | 2  |                          | p   | 1  | 2  |                            | p   | 2  | 2  |
            +-----+----+----+                          +-----+----+----+                            +-----+----+----+

            slice :=arr[1:2]                           slice :=arr[1:2]                             slice :=arr[1:2]

arr 是一个含有三个元素的数组，slice从arr中切了一个元素，由于切片的最后一个元素1是数组的索引是1，距离数组的最大长度还是1，因此slice的容量为2。当修改slice的第一个元素，由于slice底层是arr数组，因此arr的第二个元素也相应被修改。使用append方法给slice追加元素的时候，由于slice的容量还未满，因此等同于扩展了slice指向数组的内容，可以理解为重新切了一个数组内容附给slice，同时修改了数组的内容。

超出容量的append

如果接着append一个元素，那么数组肯定越界。此时append的原理大致如下：

  1. 创建一个新的临时切片t，t的长度和slice切片的长度一样，但是t的容量是slice切片的2倍，一个动态规划的方式。新建切片的时候，底层也创建了一个匿名的数组，数组的长度和切片容量一样。
  2. 复制s里面的元素到t里，即填入匿名数组中。然后把t赋值给slice，现在slice的指向了底层的匿名数组。
  3. 转变成小于容量的append方法。
       +----+----+----+                                +----+----+----+----+----+----+
       |    |    |    |                                |    |    |    |    |    |    |
 arr   | 0  |333 |444 |                                | 333| 444|    |    |    |    |
       +----+----+----+                                +----+----+----+----+----+----+
               ^    ^                                    ^     ^
               |    |                                    |     |
               |    |                                    +-----+
               +----+           +--------------->        |
               |                                         |
               |                                         +
            +--+--+----+----+                          +-----+-----+-----+
            |     |    |    |                          |     |     |     |
            | p   | 2  | 2  |                          | p   |  2  |  6  |
            +-----+----+----+                          +-----+-----+-----+

            slice :=arr[1:2]                          t := make([]int, len=2, cap=6)

                                                                  +
                                                                  |
                                                                  |
                                                                  |
                                                                  |
                                                                  v


                                                       +----+----+----+----+----+----+
                                                       |    |    |    |    |    |    |
                                                       | 333| 444|555 |    |    |    |
                                                       +----+----+----+----+----+----+
                                                         ^         ^
                                                         |         |
                                                         +----+----+
                                                         |
                                                         |
                                                         +
                                                       +-----+-----+-----+
                                                       |     |     |     |
                                                       | p   |  3  |  6  |
                                                       +-----+-----+-----+

                                                        slice = t

上面的图示描述了大于容量的时候append的操作原理。新生成的切片其依赖的数组和原来的数组就没有关系了，因此在修改新的切片元素，旧的数组也不会有关系。至于临时的切片t，将会被golang的gc回收。当然arr或它衍生的切片都没有应用的时候，也会被gc所回收。

slice和array的关系十分密切，通过两者的合理构建，既能实现动态灵活的线性结构，也能提供访问元素的高效性能。当然，这种结构也不是完美无暇，共用底层数组，在部分修改操作的时候，可能带来副作用，同时如果一个很大的数组，那怕只有一个元素被切片应用，那么剩下的数组都不会被垃圾回收，这往往也会带来额外的问题。

作为函数参数的切片

直接改变切片

回到最开始的问题，当函数的参数是切片的时候，到底是传值还是传引用？从changeSlice函数中打出的参数s的地址，可以看出肯定不是传引用，毕竟引用都是一个地址才对。然而changeSlice函数内改变了s的值，也改变了原始变量slice的值，这个看起来像引用的现象，实际上正是我们前面讨论的切片共享底层数组的实现。

即切片传递的时候，传的是数组的值，等效于从原始切片中再切了一次。原始切片slice和参数s切片的底层数组是一样的。因此修改函数内的切片，也就修改了数组。

                                                +-----+----+-----+
                                                |     |    |     |
                 +-----------------------------+| p   |  3 |  3  |
                 |          +                   +-----+----+-----+
                 |          |
                 |          |                     s
                 |          |
                 |          |
                 v          v
               +----+----+-----+
               |    |    |     |
       arr     | 0  |  1 |  2  |
               +----+----+-----+
                 ^           ^
                 |           |
                 |           |
                 +-----------+
                 |
                 |
               +-+--+----+-----+
               |    |    |     |
               |  p |  3 |  3  |
               +----+----+-----+


                  slice

例如下面的代码：

    slice := make([]int, 2, 3)
    for i := 0; i < len(slice); i++ {
        slice[i] = i
    }

    fmt.Printf("slice %v %p \n", slice, &slice)

    ret := changeSlice(slice)
    fmt.Printf("slice %v %p, ret %v \n", slice, &slice, ret)

    ret[1] = 1111

    fmt.Printf("slice %v %p, ret %v \n", slice, &slice, ret)
}

func changeSlice(s []int) []int {
    fmt.Printf("func s %v %p \n", s, &s)
    s = append(s, 3)
    return s
}

输出：

slice [0 1] 0xc42000a1e0 
func s [0 1] 0xc42000a260 
slice [0 1] 0xc42000a1e0, ret [0 1 3] 
slice [0 1111] 0xc42000a1e0, ret [0 1111 3]

从输出可以看出，当slice传递给函数的时候，新建了切片s。在函数中给s进行了append一个元素，由于此时s的容量足够到，并没有生成新的底层数组。当修改返回的ret的时候，ret也共用了底层的数组，因此修改ret的原始，相应的也看到了slice的改变。

append 操作

如果在函数内，append操作超过了原始切片的容量，将会有一个新建底层数组的过程，那么此时再修改函数返回切片，应该不会再影响原始切片。例如下面代码：

 func main() {
    slice := make([]int, 2, 2)
    for i := 0; i < len(slice); i++ {
        slice[i] = i
    }

    fmt.Printf("slice %v %p \n", slice, &slice)

    ret := changeSlice(slice)
    fmt.Printf("slice %v %p, ret %v \n", slice, &slice, ret)

    ret[1] = -1111

    fmt.Printf("slice %v %p, ret %v \n", slice, &slice, ret)
}

func changeSlice(s []int) []int {
    fmt.Printf("func s %v %p \n", s, &s)
    s[0] = -1
    s = append(s, 3)
    s[1] =  1111
    return s
}

输出：

slice [0 1] 0xc42000a1a0 
func s [0 1] 0xc42000a200 
slice [-1 1] 0xc42000a1a0, ret [-1 1111 3] 
slice [-1 1] 0xc42000a1a0, ret [-1 -1111 3]

从输出可以很清楚的看到了我们的猜想。 即函数中先改变s第一个元素的值，由于slice和s都共用了底层数组，因此无论原始切片slice还是ret，第一个元素都是-1.然后append操作之后，因为超出了s的容量，因此会新建底层数组，虽然s变量没变，但是他的底层数组变了，此时修改s第一个元素，并不会影响原始的slice切片。也就是slice[1]还是1，而ret[1]则是-1。最后在外面修改ret[1]为 -1111，也不会影响原始的切片slice。

通过上面的分析，我们大致可以下结论，slice或者array作为函数参数传递的时候，本质是传值而不是传引用。传值的过程复制一个新的切片，这个切片也指向原始变量的底层数组。（个人感觉称之为传切片可能比传值的表述更准确）。函数中无论是直接修改切片，还是append创建新的切片，都是基于共享切片底层数组的情况作为基础。也就是最外面的原始切片是否改变，取决于函数内的操作和切片本身容量。

传引用方式

array和slice作为参数传递的过程基本上是一样的，即传递他们切片。有时候我们需要处理传递引用的形式。golang提供了指针很方便实现类似的功能。

func main() {
    slice := []int{0, 1}
    fmt.Printf("slice %v %p \n", slice, &slice)

    changeSlice(&slice)
    fmt.Printf("slice %v %p \n", slice, &slice)

    slice[1] = -1111

    fmt.Printf("slice %v %p \n", slice, &slice)
}

func changeSlice(s *[]int) {
    fmt.Printf("func s %v %p \n", *s, s)
    (*s)[0] = -1
    *s = append(*s, 3)
    (*s)[1] =  1111
}

输出如下：

slice [0 1] 0xc42000a1e0 
func s [0 1] 0xc42000a1e0 
slice [-1 1111 3] 0xc42000a1e0 
slice [-1 -1111 3] 0xc42000a1e0

从输出可以看到，传递给函数的是slice的指针，函数内对对s的操作本质上都是对slice的操作。并且也可以从函数内打出的s地址看到，至始至终就只有一个切片。虽然在append过程中会出现临时的切片或数组。

总结

golang提供了array和slice两种序列结构。其中array是值类型。slice则是复合类型。slice是基于array实现的。slice的第一个内容为指向数组的指针，然后是其长度和容量。通过array的切片可以切出slice，也可以使用make创建slice，此时golang会生成一个匿名的数组。

因为slice依赖其底层的array，修改slice本质是修改array，而array又是有大小限制，当超过slice的容量，即数组越界的时候，需要通过动态规划的方式创建一个新的数组块。把原有的数据复制到新数组，这个新的array则为slice新的底层依赖。

数组还是切片，在函数中传递的不是引用，是另外一种值类型，即通过原始变量进行切片传入。函数内的操作即对切片的修改操作了。当然，如果为了修改原始变量，可以指定参数的类型为指针类型。传递的就是slice的内存地址。函数内的操作都是根据内存地址找到变量本身。

参考资料：Go 切片：用法和本质

Golang 切片与函数参数"陷阱"
冷月醉雪的博客
02-06 1082
    线性结构是计算机最常用的数据结构之一。无论是数组(arrary)还是链表(list)，在编程中不可或缺。golang也有数组，不同于别的语言，golang还提供了切片(slice)。切片比数组有更好的灵活性，具有某些动态特性。然而切片又不像动态语言的列表。不明白切片的基本实现，写程序时容易掉"坑"里。 slice参数     本来写一个堆排序，使用了golang的slice来做堆，可是...
Golang 切片与函数参数 "陷阱"
冷月醉雪的博客
02-26 3036
slice 基本实现    Golang中的slice，是一个看似array却不是array的复合结构。切片顾名思义，就是数组切下来的一个片段。slice结构大致存储了三个部分，第一部分为指向底层数组的指针ptr，其次就是切片的大小len和切片的容量cap：         有一个数组arr是一个包含五个int类型的结构，它的切片slice只是从其中取了1到3这几个数字。我们同样可以在生成一...
golang中切片作为函数参数
m0_50867847的博客
08-19 634
如果修改初始化stack时的capacity为0或1，则发现Caller和Callee中的stack指针地址不同，因为在Callee中进行了数组扩容，切片指向的底层数组已经有所不同。回顾下slice的结构，gopl中写到，一个slice由三个部分构成：指针、长度和容量。的修改都不会影响到调用者函数（Caller）中的slice结构（Callee中append的元素将不会被Caller访问到）在被调用函数（Callee）中的slice是该指针的一个副本，在被调用函数中对副本进行。
GoLang之切片作为函数参数(3)
weixin_52690231的博客
06-04 551
GoLang之切片作为函数参数(3)
golang 切片截取参数详解
热门推荐
zhngcho的博客
09-05 2万+
以 s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}为例 0. 建议：做slice截取时建议用两个参数，尤其是从底层数组进行切片操作时，因为这样在进行第一次append操作时，会给切片重新分配空间，这样减少切片对数组的影响。 1. 结论：s = s[low : high : max] 切片的三个参数的切片截取的意义为 low为截取的起始下标（含）， high为窃...
Golang 切片与函数参数“陷阱”
Shanks
02-08 278
以下内容转载自https://studygolang.com/articles/9876 线性结构是计算机最常用的数据结构之一。无论是数组（arrary）还是链表（list），在编程中不可或缺。golang也有数组，不同于别的语言，golang还提供了切片（slice）。切片比数组有更好的灵活性，具有某些动态特性。然而切片又不像动态语言的列表（Python list）。不明白切片的基本实现，写程序的时候容易掉“坑”里。 slice参数 本来写一个堆排序，使用了golang的slice来做堆，可是发现.
Golang-切片与数组的关系及性能
qq_23587709的博客
03-01 666
1. 切片的本质 在go语言当中，切片（slice）是使用最为频繁的数据结构之一，其原因在于它在处理同类型数据序列有着方便且高效的特点，所以今天我就来和大家聊聊我对切片的理解！ 1.1 数组 首先，谈到切片，肯定是不能避开数组的，因为切片是在数组之上的抽象数据类型。数组由长度和类型两部分组成，如[3]int类型表示由 3 个 int 整型组成的数组。数组以索引方式进行访问，例如表达式 s[n] 访问数组的第 n 个元素。数组的长度是固定的，长度是数组类型的一部分。长度不同的 2 个数组是不可以相互赋值
golang 击破slice中append陷阱
m0_38023144的博客
09-19 786
golang函数中切片使用append函数的一些陷阱
《Go题库·1》Golang里的数组和切片有了解过吗？
GOLANG ROADMAP
06-09 291
题目来源： 深信服、知乎、跟谁学 题目解析： GOALNG ROADMAP社区 答案 1：（溪尾） 数组长度是固定的，而切片是可变长的。可以把切片看作是对底层数组的封装，每个切片的底层数据结构中，一定会包含一个数组。数组可以被称为切片的底层数组，切片也可以被看作对数组某一连续片段的引用。因此，Go 中切片属于引用类型，而数组属于值类型，通过内建函数 len，可以取得数组和切片的长度。通过内建函数 cap，可以得到数组和切片的容量。但是数组的长度和容量是相等的，并且都不可变，而且切片容量是有变化规律的。 .
golang 性能优化
07-12
此外,Golang标准库中的`strconv`包提供了多种功能强大的函数,用于处理不同类型与字符串之间的转换: - `AppendBool`, `AppendFloat`, `AppendInt`, `AppendUint`: 将各种类型的值追加到字节切片中。 - `FormatBool`,...
go语言 切片做函数的参数
m0_38068812的博客
12-23 946
通过操作元素的地址，改变元素  package main import ( "fmt" "math/rand" "time" ) func initData(s []int) { //设置种子 rand.Seed(time.Now().UnixNano()) for i := 0; i &lt; len(s); i++ { s[i] = rand.Intn(100) /...
Golang 切片做参数
duapple的博客
11-30 1182
因此，想要完全修改切片，使用切片的指针作为参数。如果只是修改切片的元素，直接传递切片即可。
Golang 学习 - 切片
weixin_46024722的博客
04-25 163
为什么使用切片？ 数组的容量固定，不能自动拓展。 值传递。因为数组作为函数参数时，将整个数组值拷贝一份给形参，内存消耗大，效率低。 在 Go语言中，我们几乎可以在所有场景中，使用切片替换数组来使用。 切片的本质： 不是一个数组的指针，而是一种数据结构体，用来操作数组内部元素。 切片的使用： 切片与数组定义区别： – 创建数组时，[2] 指定数组长度。 – 创建切片时，[] 为空，或者 […...
golang面试题(3):切片使用陷阱
Steven的专栏
04-20 485
golang中slice切片面试题
Go 切片(slice)之用法和本质
AMimiDou_212
11-24 2061
引言 Go的切片类型为处理同类型数据序列提供一个方便而高效的方式。切片是引用类型，修改其会影响原始数据。 切片有些类似于其他语言中的数组，但是有一些不同寻常的特性。 本文将深入切片的本质，并讲解它的用法。 数组 Go的切片是在数组之上的抽象数据类型（Go的切片底层数据结构是数组），因此在了解切片之前必须要先理解数组。 数组类型定义了长度和元素类型。例如， [4]int 类型表示一个四个整数的数组。...
golang中的slice操作
weixin_34206899的博客
02-26 457
本文总结了Go语言中切片的一些使用技巧和在实际使用中可能会踩“坑”的地方上篇文章回顾：bats-Bash自动化测试工具                                                   Go语言中的切片切片(slice)是Go语言中最基本和最常用的数据结构之一，在本文中希望可以帮助读者更好的使用这一数据结构。                            ...
Go语言Slice操作.
JieLinDee的专栏
06-24 2969
1、基本用法： a = append(a, b...) 例如：list = appened(list,[]int{1,2,3,4}...) 可以用来合并两个列表. 不用这样了 ：list := make([]int,len(list1)+len(list2)) 然后再copy(list,list1) copy(list[len(list1):],list2) 2、Cop
Golang——切片实现栈
最新发布
qq_61453210的博客
05-20 413
栈是一种先进后出的线性表，简称LIFO。因为在Golang中数组定义后长度不可以改变，因此这里通过切片实现栈操作。栈和队列的操作很相似，但是队列是先进先出的。Peek方法实现显示栈中元素操作，先判断栈是否为空栈，然后通过for...range...循环出栈。两种入栈操作，这里和队列的入队列操作一样。第二种一次性添加多个元素。IsSize方法 返回栈中元素的个数。Pot方法 返回栈顶元素，栈先进后出因此返回栈最后进入的元素。Pop方法实现出栈操作，每次返回栈尾元素。定义结构体，并创建栈，初始化空栈。
Golang基础-数据结构-切片（slice）
ITman1996的博客
10-06 1077
定义 为什么需要切片？ 保存不确定长度的数据 切片是数组的一个引用，是引用类型 切片的定义：var 变量名 []类型 例如： var a []string //声明一个字符串切片 var b = []int{} //声明一个整型切片并初始化 var c = []bool{false, true} //声明一个布尔切片并初始化 var d = []bool{false, true} //声明一个布尔切片并初始化 fmt.Println(a)
Go语言切片深度解析与实战
`copy()`函数用于将一个切片的内容复制到另一个切片，它返回实际复制的元素数量。这是一个高效且安全的方法，可以避免不必要的内存分配。 03.3.5 多维切片 Go支持多维切片，可以创建类似于矩阵的结构。多维切片在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值