go中的切片

最新推荐文章于 2025-11-25 08:32:04 发布

原创最新推荐文章于 2025-11-25 08:32:04 发布 · 1.2k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#golang #开发语言 #后端

go 专栏收录该内容

9 篇文章

订阅专栏

文章详细介绍了Go语言中切片的定义方式、基本操作（如添加、复制和合并），以及切片的cap（容量）和len（长度）概念。重点讨论了切片扩容的原理和扩容策略，包括扩容触发条件和内存分配行为。

demo1:切片定义的几种方式

package main

import "fmt"

/*
切片定义的几种方式

数组和切片区别：
使用数组传参是值传递，而使用切片传参是引用传递
数组定义好长度之后不可修改，而切片可以理解为动态数组，长度可修改

*/

func main() {
    //方法1:直接创建
    s1 := []string{"1", "2", "3"}
    fmt.Printf("%T\n", s1)
    fmt.Println(len(s1))
    fmt.Println(s1)

    fmt.Println("--------------------------------------")
    //方法2:使用make定义，但是需要加上长度,cap可加可不加
    s2 := make([]string, 3)     //s2:=make([]string, 3,5)   加cap写法
    fmt.Printf("%T\n", s2)
    fmt.Println(len(s2))
    fmt.Println(s2)

    fmt.Println("--------------------------------------")
    //方法3：数组变切片
    arr := [3]string{"1", "2", "3"}
    s3 := arr[1:2]
    fmt.Printf("%T\n", s3)
    fmt.Printf("%T\n", arr)
    fmt.Println(len(s3))
    fmt.Println(s3)

    fmt.Println("--------------------------------------")
    //方法4：new
    s4 := new([]string)
    fmt.Printf("%T\n", s4)
    //fmt.Println(len(s4)) //没有长度
    fmt.Println(s4) //&[]

}

demo2: 切片的基本操作

package main

import "fmt"

/*
切片的基本操作：添加、复制、合并、删除
*/

func main() {
    s1 := []string{"1", "2", "3"}

    //添加
    s1 = append(s1, "4", "5")
    fmt.Println(s1)

    //复制
    s2 := []string{}
    copy(s2, s1)
    fmt.Println(s2) //这里s2为空，因为没定义长度
    //拷贝时，目标对象长度为多少就只能复制多少
    s3 := make([]string, len(s1))
    copy(s3, s1)
    fmt.Println(s3)

    //把两个切片合并
    s2 = append(s1, s3...) //省略号是规定的参数
    fmt.Println(s2)

    //数组中删除元素:先把数组变成切片，再把两个切片合并
    s4 := s2[:]
    s4 = append(s2[0:2], s2[4:]...)
    fmt.Println(s4)
}

demo3: 切片的cap和len

package main

import "fmt"

/*
切片的容量（cap）和长度（len)

slice的底层是使用数组实现的，同一个数组的切片会共享内存，但如果切片扩容超过切片的原有容量cap会触发扩容机制，该切片就会自己独立开辟全新内存空间。

slice的append扩容问题：扩容阶段因为需要整体开辟全新的内存空间，因此扩容阶段会影响速度。python的list中底层实际上也是数组，也会面临扩容影响速度的问题。

python的同一list中可以存不同的数据类型。
*/

func main() {
    //不设置cap时，len和cap大小一致
    s1 := []string{"1", "2", "3"}
    fmt.Println(len(s1))    //3
    fmt.Println(cap(s1))    //3

    s2 := make([]int, 5)    
    fmt.Println(len(s2))    //3
    fmt.Println(cap(s2))    //3

    s3 := make([]int, 5, 8) //设置了容量cap
    fmt.Println(len(s3))    //5
    fmt.Println(cap(s3))    //8

    //通过数组取切片：cap为切片起始位置之后的数组长度
    s4 := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    s5 := s4[2:5]        
    fmt.Println(len(s5)) //3
    fmt.Println(cap(s5)) //8

    //append函数遇到make问题：如果用make创建切片时定义了长度，append操作会在原有元素之后进行插入。如果没有定义长度，append操作则是对默认元素0进行替换
    s6 := make([]int, 3)
    s6 = append(s6, 1)
    fmt.Println(s6) //[0 0 0 1]

    s7 := make([]int, 0)
    s7 = append(s7, 1)
    fmt.Println(s7) //  [1]

}

demo4:切片扩容

案例1：

package main

import (
    "fmt"
)

func main() {

    data := [...]int{0, 1, 2, 3, 4, 10: 0} //数组
    s := data[:2:3]
    fmt.Println(s)
    fmt.Println(len(s), cap(s))

    s = append(s, 100, 200, 300) // 一次 append 三个值，超出 s.cap 限制。

    fmt.Println(s, data)         // 重新分配底层数组，与原数组无关。
    fmt.Println(&s[0], &data[0]) // 比对底层数组起始指针。

}

从输出结果可以看出：append 后的 s 被重新分配了底层数组（也就是说 s 的底层数组不再是 data，那么修改 s 的值不会再影响 data，它们不再有关联），并把原数组中的值拷贝到新数组中。这是因为超出了原切片的容量。在上例中，如果只追加一个值，则不会超过 s.cap 限制，也就不会重新分配。

切片的自动扩容策略是这样的：（文章：简单说说go语言Slice的底层实现_Liuzhiwang29的博客-优快云博客简单说说go语言Slice的底层实现通过分析源码对这一点提出了质疑）通常以 2 倍容量进行扩容，并重新分配底层数组（新底层数组的容量也变大）。如果切片的容量小于 1024 个元素，扩容的时候就翻倍增加容量。一旦元素个数超过 1024 个元素，那么增长因子就变成 1.25 ，即每次增加原来容量的四分之一。注意：扩容扩大的容量都是针对原来的容量而言的，而不是针对原来数组的长度而言的。

所以，在大批量添加数据时，建议一次性分配足够大的空间，以减少内存分配和数据复制开销。或初始化足够长的 len 属性，改用索引号进行操作。及时释放不再使用的 slice 对象，避免持有过期数组，造成 GC 无法回收。

slice中 cap 重新分配规律：

package main

import (
    "fmt"
)

func main() {

    s := make([]int, 0, 1)
    fmt.Println(s)
    
    c := cap(s)                        //计算容量
    fmt.Println(c)

    for i := 0; i < 50; i++ {
        s = append(s, i)               //按理说 append 第2个元素时就超出了cap，这时会重新分配底层数组来扩大cap
        if n := cap(s); n > c {
            fmt.Printf("cap: %d -> %d\n", c, n)
            c = n
        }
    }

}

输出结果：

[]
1
cap: 1 -> 2
cap: 2 -> 4
cap: 4 -> 8
cap: 8 -> 16
cap: 16 -> 32
cap: 32 -> 64

我们可以发现，通常以 2 倍的 cap 重新分配。

提一嘴哈，如果给切片 append 元素时，不超切片容量就没事，操作的还是原数组：

package main

import (
    "fmt"
)

func main() {

    data := [...]int{0, 1, 2, 3, 4, 10: 0} //数组
    s := data[:2:5]                        //将切片容量扩大到5
    fmt.Println(s)
    fmt.Println(len(s), cap(s))

    s = append(s, 100, 200, 300) // 一次 append 三个值，这次没超出 s.cap 限制。

    fmt.Println(s, data)         
    fmt.Println(&s[0], &data[0]) // 比对底层数组起始指针

}

输出结果：

[0 1]
2 5
[0 1 100 200 300] [0 1 100 200 300 0 0 0 0 0 0]
0xc00004a060 0xc00004a060

案例2：

package main

import "fmt"

//slice的扩容

func main() {
    arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
    s1 := arr[2:6]      
    s2 := s1[3:5]
    fmt.Printf("s1=%v，len(s1)=%d，cap(s1)=%d\n", s1, len(s1), cap(s1)) //2,3,4,5
    fmt.Printf("s2=%v，len(s2)=%d，cap(s2)=%d\n", s2, len(s2), cap(s2)) //5,6,为什么s2中取到6，是因为slice支持向后扩容

    //slice的操作:向slice中添加元素
    s3 := append(s2, 10)
    s4 := append(s3, 11)
    s5 := append(s4, 12)
    fmt.Println("s3，s4，s5：", s3, s4, s5)
    fmt.Println("arr：", arr)    //为什么没有11，12?   是因为不能超过cap，如果超过cap则会重新分配一个数组进行存储

}