go切片（常见用法操作与原理）

最新推荐文章于 2023-10-26 11:44:33 发布
最新推荐文章于 2023-10-26 11:44:33 发布
阅读量1.3k 收藏 3
点赞数 2
分类专栏： go 笔记 文章标签： go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45701131/article/details/113005736
版权
go 同时被 2 个专栏收录
12 篇文章 0 订阅
订阅专栏
笔记
12 篇文章 0 订阅
订阅专栏

Golang中切片（slice）由于作为存储数据常用容器，而非常重要。对比数组，数组是一个由固定长度的特定类型元素组成的序列。而切片是一种简化版的动态数组，由于长度不固定，因此灵活得多。切片的结构定义，即reflect.SliceHeader:

type SliceHeader struct{
    ptr unsafe.Pointer
    Len int
    Cap int
}

由3部分构成。第一个是指向底层字节数组；
第二个是切片的长度（元素的个数）；
第三个表示切片指向的内存空间和最大容量（对应元素的个数，而不是字节数）例如，x := []int{2,3,5,7,11}和y := x[1:3]两个切片对应的内存结构如图所示：
在这里插入图片描述

  • 切片定义方式：
var (
    a []int               // nil切片, 和 nil 相等, 一般用来表示一个不存在的切片
    b = []int{}           // 空切片, 和 nil 不相等, 一般用来表示一个空的集合
    c = []int{1, 2, 3}    // 有3个元素的切片, len和cap都为3
    d = c[:2]             // 有2个元素的切片, len为2, cap为3
    e = c[0:2:cap(c)]     // 有2个元素的切片, len为2, cap为3
    f = c[:0]             // 有0个元素的切片, len为0, cap为3
    g = make([]int, 3)    // 有3个元素的切片, len和cap都为3
    h = make([]int, 2, 3) // 有2个元素的切片, len为2, cap为3
    i = make([]int, 0, 3) // 有0个元素的切片, len为0, cap为3
)
  • 切片使用for循环的三种遍历方式：
for i:= range c{
	fmt.Printf("c[%d]:%d\n",i,c[i])
}
for i,v:=range d{
	fmt.Printf("d[%d]:%d\n",i,v)
}
for x:=0;x<len(e);x++{
	fmt.Printf("e[%d]:%d\n",x,e[x])
}
  • 添加切片元素演示：

1.结尾追加

	var a_a [] int
	//向尾部添加切片
	a_a = append(a_a,1)  //追加一个元素
	fmt.Println("结尾添加元素方式:\n",a_a)
	a_a = append(a_a,4,2,3)  //追加多个元素，手写解包方式
	fmt.Println(a_a)
	a_a = append(a_a,[]int{1,2,3}...)  //追加一个切片，切片需要解包
	fmt.Println(a_a)

2，开头追加

	var a_a1 = []int {0}
	//在切片开头添加元素。开头添加切片一般会导致内存重新分配，而且会导致已有元素重新复制一次。因此一般性能比尾部追加差很多
	a_a1 = append(a_a1,-1,111)
	fmt.Println("开头添加元素两种方式:\n",a_a1)
	a_a1 = append([]int{-3,-2,-1},a_a1...)  //在开头添加一个切片
	fmt.Println(a_a1)

3.在中间插入。分别append()函数，append()函数和copy()函数组合方式。

var a_a2 = [] string {"w","a","yu","字"}
	//在切片中间插入元素
	i:=2
	a_a2 = append(a_a2[:i],append([]string{"加入"},a_a2[i:]...)...)  //在第i个位置插入"加入"
	fmt.Println("在中间加入元素的方式:\n",a_a2)
	a_a2 = append(a_a2[:3],append([]string{"yuxuan","siling"},a_a2[3:]...)...)
	fmt.Println(a_a2)  //在第3个位置加入切片

	var a_a3 =[] int {1,2,3,4}
	//用copy()和append()组合可以避免创建临时切片，同样是完成添加元素的操作
	a_a3 = append(a_a3,0)  //切片扩展一个空间
	copy(a_a3[i+1:],a_a3[i:])  //a【i：】向后移动一个位置
	a_a3[i] = 5  //设置添加新的元素
	fmt.Println("copy的方式向中间添加:\n",a_a3)
	x:=[] int {6,7,8}
	a_a3= append(a_a3,x...)  //为x切片扩展足够的空间
	copy(a_a3[i+len(x):],a_a3[i:])
	copy(a_a3[i:],x)
	fmt.Println(a_a3)
  • 删除切片元素演示
    1.删除尾部
var N int
	N = 2
	var a_r = [] int {1,2,3,4,5,6}
	//尾部删除
	a_r = a_r[:len(a_r)-1]  //删除尾部1个元素
	fmt.Println("从结尾删:\n",a_r)
	a_r = a_r[:len(a_r)-N]  //再删除尾部N个元素
	fmt.Println(a_r)

2.删除开头。三种方式：1.直接移动。2.使用append（）不移动指针，而将后面的数据向开头移动。3.使用copy（）删除开头的元素

	var a_r1 = [] int {12,13,14,15}
	//头部删除.删除开头的元素可以直接移动数据指针
	a_r1 = a_r1[1:]  //删除开头1个元素
	fmt.Println("从开头删:\n",a_r1)
	a_r1 = a_r1[N:]  //再删除开头N个元素
    fmt.Println(a_r1)
    
	//也可以不移动数据指针，而将后面的数据向开头移动
	a_r2 := [] int {16,17,18,19,20}
	a_r2=append(a_r2[:0],a_r2[1:]...)  //删一个
	fmt.Println(a_r2)
	a_r2=append(a_r2[:0],a_r2[N:]...)  //删N个
	fmt.Println(a_r2)
	
	var a_r3 = [] int {21,22,23,24}
	a_r3 = a_r3[:copy(a_r3,a_r3[1:])]  //开头删一个
	fmt.Println(a_r3)
	a_r3 = a_r3[:copy(a_r3,a_r3[N:])]  //删N个
	fmt.Println(a_r3)

3.删除中间

var a_r5 = [] int {1,2,3,4,5}
	//删除中间元素
	a_r5 = append(a_r5[:1],a_r5[2:]...)  //删除中间第2个元素
	fmt.Println("删除中间元素\n",a_r5)
	var a_r6 = [] int {40,41,42,43,44}
	x:=3
	fmt.Println("a_r6切片删除前：",a_r6)
	a_r6 = a_r6[:1+copy(a_r6[1:],a_r6[1+x:])]  //从第2个位置开始删除3个元素
	fmt.Println("删除中间元素后：",a_r6)

4.删除两头

var a_r4 = [] int {30,31,32,33,34}
	//删除两头
	a_r4 = a_r4[1:4]
	fmt.Println("删除两头\n",a_r4)

上述定义切片，添加切片元素，删除切片元素演示部分的代码如下：

package main

import (
	"fmt"
)

//定义方式
var (
	a []int     //nil切片，和nil相等，一般用来表示一个不存在的切片
	b = []int{} //空切片，和nil不相等，一般用来表示一个空的集合
	c = []int{1,2,3}  //有三个元素的切片，len和cap都为3
	d = c[:2]  //有2个元素的切片，len为2，cap为3
	e = c[0:2:cap(c)]  //有2个元素的切片，len为2，cap为3
	f = c[:0]  //有0个元素的切片，len为0，cap为3
	g = make([]int,3)  //有三个元素的切片，len和cap都为3
	h = make([]int,2,3)  //有2个元素的切片，len为2，cap为3
	i = make([]int,0,3)  //有0个元素的切片，len为0，cap为3
)
//切片三种读取方式类似于数组
func read_slice(){
    fmt.Println("读取切片的三种方式")
	for i:= range c{
		fmt.Printf("c[%d]:%d\n",i,c[i])
	}
	for i,v:=range d{
		fmt.Printf("d[%d]:%d\n",i,v)
	}
	var x int
	for x=0;x<len(e);x++{
		fmt.Printf("e[%d]:%d\n",x,e[x])
	}
}
//append向切片添加元素
func slice_append(){
	var a_a [] int
	//向尾部添加切片
	a_a = append(a_a,1)  //追加一个元素
	fmt.Println("结尾添加元素方式:\n",a_a)
	a_a = append(a_a,4,2,3)  //追加多个元素，手写解包方式
	fmt.Println(a_a)
	a_a = append(a_a,[]int{1,2,3}...)  //追加一个切片，切片需要解包
	fmt.Println(a_a)

	var a_a1 = []int {0}
	//在切片开头添加元素。开头添加切片一般会导致内存重新分配，而且会导致已有元素重新复制一次。因此一般性能比尾部追加差很多
	a_a1 = append(a_a1,-1,111)
	fmt.Println("开头添加元素方式:\n",a_a1)
	a_a1 = append([]int{-3,-2,-1},a_a1...)  //在开头添加一个切片
	fmt.Println(a_a1)

	var a_a2 = [] string {"w","a","yu","字"}
	//在切片中间插入元素
	i:=2
	a_a2 = append(a_a2[:i],append([]string{"加入"},a_a2[i:]...)...)  //在第i个位置插入"加入"
	fmt.Println("在中间加入元素的方式:\n",a_a2)
	a_a2 = append(a_a2[:3],append([]string{"yuxuan","siling"},a_a2[3:]...)...)
	fmt.Println(a_a2)  //在第3个位置加入切片

	var a_a3 =[] int {1,2,3,4}
	//用copy()和append()组合可以避免创建临时切片，同样是完成添加元素的操作
	a_a3 = append(a_a3,0)  //切片扩展一个空间
	copy(a_a3[i+1:],a_a3[i:])  //a【i：】向后移动一个位置
	a_a3[i] = 5  //设置添加新的元素
	fmt.Println("copy的方式向中间添加:\n",a_a3)
	x:=[] int {6,7,8}
	a_a3= append(a_a3,x...)  //为x切片扩展足够的空间
	copy(a_a3[i+len(x):],a_a3[i:])
	copy(a_a3[i:],x)
	fmt.Println(a_a3)

}
//Go语言并没有对删除切片元素提供专用的语法或者接口，需要使用切片本身的特性来删除元素，根据要删除元素的位置有三种情况，
//分别是从开头位置删除、从中间位置删除和从尾部删除，其中删除切片尾部的元素速度最快。
func slice_remove(){
	var N int
	N = 2
	var a_r = [] int {1,2,3,4,5,6}
	//尾部删除
	a_r = a_r[:len(a_r)-1]  //删除尾部1个元素
	fmt.Println("从结尾删:\n",a_r)
	a_r = a_r[:len(a_r)-N]  //再删除尾部N个元素
	fmt.Println(a_r)

	var a_r1 = [] int {12,13,14,15}
	//头部删除.删除开头的元素可以直接移动数据指针
	a_r1 = a_r1[1:]  //删除开头1个元素
	fmt.Println("从开头删:\n",a_r1)
	a_r1 = a_r1[N:]  //再删除开头N个元素
    fmt.Println(a_r1)
	//也可以不移动数据指针，而将后面的数据向开头移动
	a_r2 := [] int {16,17,18,19,20}
	a_r2=append(a_r2[:0],a_r2[1:]...)  //删一个
	fmt.Println(a_r2)
	a_r2=append(a_r2[:0],a_r2[N:]...)  //删N个
	fmt.Println(a_r2)

	var a_r3 = [] int {21,22,23,24}
	a_r3 = a_r3[:copy(a_r3,a_r3[1:])]  //开头删一个
	fmt.Println(a_r3)
	a_r3 = a_r3[:copy(a_r3,a_r3[N:])]  //删N个
	fmt.Println(a_r3)

	var a_r4 = [] int {30,31,32,33,34}
	//删除两头
	a_r4 = a_r4[1:4]
	fmt.Println("删除两头\n",a_r4)

	var a_r5 = [] int {1,2,3,4,5}
	//删除中间元素
	a_r5 = append(a_r5[:1],a_r5[2:]...)  //删除中间第2个元素
	fmt.Println("删除中间元素\n",a_r5)
	var a_r6 = [] int {40,41,42,43,44}
	x:=3
	fmt.Println("a_r6切片删除前：",a_r6)
	a_r6 = a_r6[:1+copy(a_r6[1:],a_r6[1+x:])]  //从第2个位置开始删除3个元素
	fmt.Println("删除两边元素后：",a_r6)
}
func main(){
	read_slice()
	slice_append()
	slice_remove()
}
avenue轩
关注
专栏目录
【全】Go语言切片使用指南
走向CTO的路上...
10-14 394
切片是一种动态数组，可以通过make函数创建，具有长度和容量。通过指定不同的长度和容量创建切片，以扩展其使用场景。自定义切片类型并使用工厂方法创建切片。空切片与 nil 切片的区别。判断切片是否为空，利用len()函数。在函数参数中处理空切片和 nil 切片。切片可以引用数组的一部分。修改切片会影响到其底层数组。避免对共享数组的无意修改。使用append添加元素。处理超过容量时的扩容。控制append后容量增长的因素。当容量不足时，append会创建新的底层数组。创建一个新切片，确保不影响原始数据。
Golang切片的底层实现原理
m0_72560813的博客
02-26 814
golang中切片的底层实现原理，看完彻底弄懂切片如何工作的
浅谈golang slice 切片原理
12-26
slice介绍 数组的长度在定义之后无法再次修改；数组是值类型，每次传递都将产生一份副本。显然这种数据结构无法完全满足开发者的真实需求。在初始定义数组时，我们并不知道需要多大的数组，因此我们就需要“动态数组”。在Go里面这种数据结构叫slice，slice并不是真正意义上的动态数组，而是一个引用类型。slice总是指向一个底层array，slice的声明也可以像array一样，只是不需要长度，它是可变长的，可以随时往slice里面加数据。 初看起来，数组切片就像一个指向数组的指针，实际上它拥有自己的数据结构，而不仅仅是个指针。数组切片的数据结构可以抽象为以下3个变量： 1．一个指向原生数
Go 知识点（06）— for range 切片并对切片进行 append 不会造成死循环
wohu1104的专栏
04-07 691
想想下面代码会发生什么？ func main() { a := []int{1, 2, 3} for _, v := range a { a = append(a, v) fmt.Println("len(a)=", len(a)) } fmt.Printf("a is %#v", a) } 会造成死循环吗？ 答案是：不会。 对于 Go 中的 for ... range 而言，实际上在循环之前就已经获取了切片的长度，然后再执行固定次数的循环，所以上面代码打印结果是： len(a)= 4 l
第六章第一节 数组和切片
m0_54634272的博客
08-30 217
概述 数组是指一系列同一类型数据的集合。数组中包含的每个数据被称为数组元素（element），一个数组包含的元素个数被称为数组的长度。 数组长度必须是常量，且是类型的组成部分。 [2]int 和 [3]int 是不同类型。 var n int = 10 var a [n]int //err, non-constant array bound n var b [10]int //ok 操作数组 数组的每个元素可以通过索引下标来访问，索引下标的范围是从0开始到数组长度减1的位置。 var a [10]int
Go-17 使用append()为切片添加元素
浅汐
11-05 448
Go语言的内建函数append()可以为切片动态的添加元素，示例如下： var a []int a = append(a, 1) // 追加1个元素 a = append(a, 1, 2, 3) // 追加多个元素, 手写解包方式 a = append(a, []int{1,2,3}...) // 追加一个切片, 切片需要解包 不过需要注意的是，在使用 append() 函数为切片动态添加元...
golang切片内存应用技巧详解
09-18
上述方法在Go官方GitHub Wiki的SliceTricks部分都有介绍，其中列出了许多使用切片的小技巧和模式，对于深入理解切片的工作原理和应用非常有帮助。掌握这些技巧，可以帮助Go开发者更高效地进行编程。如果需要深入了解...
golang数组切片原理解析
submarineas的博客
12-18 865
数组介绍 数组是一种非常有用的数据结构，因为其占用的内存是连续分配的。由于内存连续，CPU能把正在使用的数据缓存更久的时间。而且内存连续很容易计算索引，可以快速迭代数组里的所有元素。数组的类型信息可以提供每次访问一个元素时需要在内存中移动的距离。既然数组的每个元素类型相同，又是连续分配，就可以以固定速度索引数组中的任意数据，提高工作效率。 数组声明和初始化 golang中声明数组需要告诉数组长度，以及存放数据类型，一旦初始化成功，那么存储的数据类型和数组长度就都不能改变了，如果需要存储更多的元素，就需要先创
万字长文了解Go map 常见问题与原理
weixin_44877302的博客
12-04 560
go map常见问题与原理
【Go切片源码深度剖析】：探索底层实现原理与优化
在Go语言中，切片是一种灵活且强大的数据结构，它提供了一种便捷的方式来处理数据序列。Go切片是对数组的封装，它能够动态地管理数据集合的大小，因此在使用时更加灵活和方便。本章将深入探讨切片的基本概念和其独特...
Golang-常见面试题目解析.rar
最新发布
03-19
- **并发编程**：Goroutine和Channel是Go语言并发的核心，了解它们的工作原理和使用方法。 - **接口（Interface）**：理解接口的零值、实现、空接口，以及接口在多态中的应用。 - **切片（Slice）与数组**：对比...
Golang原理分析：切片(slice)原理及扩容机制
BoringError的博客
12-04 2156
Go切片的特性：切片的本质是引用底层数组头指针+当前切片长度+底层数组大小：即array、len和cap： 使用时通过make关键字来进行初始化切片分配一个新的底层数组，或者是基于指定的数组进行切片化。
golang slice原理
ERIC_TWELL的博客
11-10 174
Slice结构体定义 slice 结构体定义如下 type slice struct { array unsafe.Pointer //指向数据的首地址指针 8字节 len int //长度 4||8字节 cap int //容量 4||8字节 } make Slice // 初始化 slice s1 := make([]int, 3, 5) fmt.Printf("s1: s1 address:%p, data
go学习备忘录 - 切片中间插入元素
weixin_41935140的博客
10-15 3119
1. 通过链式append 实现 将多个append操作组合起来，实现在切片中间插入元素： var a []int a = append(a[:i], append([]int{1}, a[i:]...)...) // 在第i个位置插入1 a = append(a[:i], append([]int{1,2,3}, a[i:]...)...) // 在第i个位置插入切片 每个链式操作中的第二个append调用都会创建一个临时切片，并将a[i:]的内容复制到新创建的切片中，然后将临时创建的切
golang 切片详解
m0_37698352的博客
08-01 2323
Go 中的切片是一种灵活且高效的表示数组的方式，并且由于其动态大小和附加功能，它们经常用来代替数组。切片是对数组的一部分的引用。它是一种数据结构，通过指定起始索引和部分长度来描述数组的一部分。这允许您像使用独立数组一样使用数组的一部分。Go语言中切片比数组更强大、更灵活、更方便，是一种轻量级的数据结构。切片是一个变长序列，用于存储相似类型的元素，不允许在同一个切片中存储不同类型的元素。它就像一个具有索引值和长度的数组，但是切片的大小是调整大小的，它们不像数组那样是固定大小的。在内部，切片和数组是相互连接的，
Go学习：切片slice的循环机制及性能
pengpengzhou的博客
04-30 1881
使用range来循环切片时，每一轮都会向同一个临时变量进行赋值即赋值拷贝，这是一个性能上的开销。从下面的测试输出能看得出临时变量的地址是不会变的，而且与切片的地址完全不同。如果切片元素包含字符串的话，用range遍历和直接寻址遍历的性能差别还是很显著的。 package main import ( "fmt" "time" ) type Person struct { Name ...
Go基础语法：切片
实力派，无需多言！
09-22 191
name 是变量名T 表示切片中的元素类型[ ]内不需要声明长度切片是引用类型，所以两个切片无法直接进行比较，切片只能和nil做比较。（ nil 表示未初始化的引用类型变量 ）切片有自己的长度和容量，我们可以通过使用内置的len(切片名)来获取长度，通过cap(切片名)获取切片的容量。// 声明一个字符串类型的切片// 声明一个 int 类型的切片并执行初始化// 声明一个 bool 类型的切片并执行初始化// [ ]// [ ]
3. golang 切片详解（看这一篇就够了）
克里斯丁的博客
10-26 707
上一篇文章介绍了 Go 语言的数组结构，我们都知道数组是定长的，长度定义好之后，不能再更改。因此，数组是不常见的，因为其长度是类型的一部分，限制了它的表达能力。更为常用的数据结构是切片，也被称作动态数组，。本篇文章就带大家一起学习下 golang 语言学习第二课：切片（slice）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值