Golang学习记录10——切片（slice）（注意append）

已于 2023-12-10 18:36:08 修改
阅读量1k 收藏 23
点赞数 19
文章标签： golang 学习 开发语言
于 2023-12-09 23:39:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dearfrienda/article/details/134819822
版权

切片的引入

  1. 切片（slice）是golang中一种特有的数据类型
  2. 数组有特定的用处，但是却有一些呆板（数组长度固定不可变当然可以使用函数添加），所以在Go语言的代码里并不是特别常见。相对的切片却是随处可见的，切片是一种建立在数组类型之上的抽象，它构建在数组之上并且提供更强大的能力和便捷。
  3. 切片（slice）是对数组一个连续片段的引用，所以切片是一个引用类型。这个片段可以是整个数组，或者是由起始和终止索引标识的一些项的子集。需要注意的是，终止索引标识的项不包括在切片内。切片提供了一个相关数组的动态窗口。
ackage main

import "fmt"

func main()  {
	//首先定义数组
	arr := [...]int{1,2,3,4,5,6}

	//切片：够建在数组之上
	var slice1, slice2 []int          //切片长度可变
	slice1 = arr[1:3]   //切出一个片段，索引从1开始，3位终止索引，不包含
	slice3 := arr[1:4] 
	slice2 = arr[:]    //整个数组
	fmt.Println(slice1)
	fmt.Println(slice2)
	fmt.Println(slice3)
	//类型
	fmt.Printf("arr类型：%T\n",arr)
	fmt.Printf("slice1类型：%T\n",slice1)
	fmt.Printf("slice2类型：%T\n",slice2)
	fmt.Printf("slice3类型：%T\n",slice3)
	//获取切片容量——可以动态变化
	fmt.Println("slice1容量：",cap(slice1))
	fmt.Println("slice2容量：",cap(slice2))
	fmt.Println("slice3容量：",cap(slice3))

}

[2 3]
[1 2 3 4 5 6]
[2 3 4]
arr类型：[6]int
slice1类型：[]int
slice2类型：[]int
slice3类型：[]int
slice1容量： 5
slice2容量： 6
slice3容量： 5
  • 首先对切片的赋值是建立在数组上的，通过指定索引，如果不指定默人开头和结尾（包含最后元素），但不管是整个数组还是片段，都需要使用[:]格式
  • 通过输出我门可以看见，数组类型为[长度]数据类型，切片为[]数据类型，所以不指定长度
  • 切片的容量大小是动态变化的，且不一定等于元素的大小。

内存分析

切片再底层由3个字段的数据结构：指向底层数组的指针、切片长度、切片容量
在这里插入图片描述

	//地址关系
	fmt.Printf("数组1的地址：%p\n",&arr[1])
	fmt.Printf("切片0位置的地址：%p\n",&slice1[0])
	fmt.Printf("切片变量位置的地址：%p\n",&slice1)

	//切片改变数组值
	arr[1] = 11
	slice1[1] = 10
	fmt.Println(arr)
	fmt.Println(slice1)

数组1的地址：0x14000118008
切片0位置的地址：0x14000118008
切片0位置的地址：0x1400011a000
[1 11 10 4 5 6]
[11 10]

由程序可以看出：

  • 切片变量结构体实际上是一个单独的变量，该结构体变量由上面的3个部分组成
  • 切片的指针指向引用数组的元素地址上
  • 切片这个结构体中指针指向的是引用的数组地址，但不是说切片就是一个指针，他是一个结构题
  • 切片为引用数据类型，通过改变切片元素的值，可以改变数组的值，当然，作为底层数据，改变数组的值，切片引用的是数组空间存储的值，那么切片值也会变。

切片的定义

  1. 定义一个切片，然后让切片去引用一个已经创建好的数组。
//方式1:通过引用数组定义
	arr := [...]int {1,2,3,4,5,6,7}
	//引用全部
	slice1 := arr[:]
	//引用片段
    slice2 := arr[1:3]
	fmt.Println(slice1)
	fmt.Println(slice2)

[1 2 3 4 5 6 7]
[2 3]
  1. 通过make内置函数来创建切片。make()底层创建一个数组，对外不可见，所以不能直接操作这个数组，需要使用slice去间接访问各元素。基本语法：make(数据类型， 长度 ， [容量])
    请添加图片描述
//方式2:通过make内置函数创建-可不指定容量(只会默认长度容量)
	slice3 := make([]int, 4)
	slice4 := make([]int, 6, 8)
	fmt.Println(cap(slice3))
	fmt.Println(cap(slice4))
	fmt.Println(slice3)
	fmt.Println(slice4)

4
8
[0 0 0 0]
[0 0 0 0 0 0]
  1. 定一个切片，直接就指定具体数组，使用原理类似make的方式。
//方式3:定义一个切片，直接就指定一个具体的数组——和方式2一样，不能直接操作着这个数组
	slice5 := []int {1,2,3}
	fmt.Println(slice5 )
	fmt.Println(cap(slice5))

[1 2 3]
3

所以，不管是什么方式，都是对数组的引用，使用make是创建一个数组空间，方式3是直接创建一个具体的数组。后两种方式只能使用slice去维护/操作数组，第一种方式可以通过数组直接操作。

切片相较于数组，主要区别在于亮点：1.数组需要固定长度，切片则不需要指定。2.数组为值类型，切片为引用类型

切片的遍历

  • 普通for循环
  • for-range循环
package main

import "fmt"

func main()  {
	//slice traceral

	//slice definition
	slice := []int{1,2,3,4,5}

	//方式1:for
	for i := 0; i < len(slice); i++ {
		fmt.Printf("alice[%v]=%v\t",i,slice[i])
	}

	//方式2:for-range
	fmt.Println("\n-------------------for-range-------------------")
	for i, v := range slice {
		fmt.Printf("alice[%v]=%v\t",i,v)
	}
}

alice[0]=1      alice[1]=2      alice[2]=3      alice[3]=4      alice[4]=5
-------------------for-range-------------------
alice[0]=1      alice[1]=2      alice[2]=3      alice[3]=4      alice[4]=5

切片注意事项

  1. 切片在定义之后不能直接使用，需要让其引用到一个数组
var slice []int
fmt.Println(slice)

[]
  1. 切片使用不能越界
var slice []int
	slice = []int{1,2,3,4}
	fmt.Println(slice[3])
	fmt.Println(slice[4]) //越界:index out of range [4] with length 4

4
panic: runtime error: index out of range [4] with length 4

goroutine 1 [running]:
main.main()
        /Users/dearfriend/golang/code/chapter8_slice/demo4/main.go:8 +0x88
exit status 2
  1. 切片简写使用：arr[:]索引省略
  2. 切片可以继续切片（对切片进行切片）切片都是指向数组，所以改变切片的值，其指向空间的值改变，对应的，指向该空间的所有切片都会改变
	var slice []int
	slice = []int{1,2,3,4}
	//对切片进行切片
	slice2 := slice[1:2]

	fmt.Println(slice)
	fmt.Println(slice2)
	//改变二次切片的值，所有值都变
	slice2[0] = 9
	fmt.Println(slice)
	fmt.Println(slice2)

[1 2 3 4]
[2]
[1 9 3 4]
[9]
  1. 切片可以动态增长:使用append函数进行增加
    append函数在底层实际上是创建了一个新的数组，append(slice1,1,2,3)表示创建一个新的数组，将原有元素放入，在将添加的元素加在后面 ，所以，原来的slice所指向的空间还是不变，不会指向新的数组。可以使用slice = append（slice，1，2）.append函数原数据智能传入切片——老数组扩容成新数组（切片指向新数组，不再指向原数组，原数组不变） 是否创建新数组，是否改变原数组取决于切片容量，见PS
    那么定义的新数组，和前面说的make定义一样，没有数组名，只能间接使用切片进行数组的维护
    请添加图片描述
	//切片动态增长
	fmt.Println("================切片动态增长===============")
	fmt.Printf("slice的长度为：%v\t slice的容量为：%v\n",len(slice),cap(slice))
	fmt.Printf("原切片指向的地址：%p\n",&slice[0])
	fmt.Println("-----------------------------------------")

	//slice追加元素
	slice = append(slice,9,8,10,11) 
	fmt.Printf("slice的长度为：%v\t slice的容量为：%v\n",len(slice),cap(slice))
	fmt.Printf("新切片指向的地址：%p\n",&slice[0])

================切片动态增长===============
slice的长度为：3         slice的容量为：5
原切片指向的地址：0x14000016098
-----------------------------------------
slice的长度为：7         slice的容量为：10
新切片指向的地址：0x1400001a050

还可以添加切片

//切片动态增长
	fmt.Println("================切片动态增长===============")
	fmt.Printf("slice的长度为：%v\t slice的容量为：%v\n",len(slice),cap(slice))
	fmt.Printf("原切片指向的地址：%p\n",&slice[0])
	fmt.Println("-----------------------------------------")

	//slice追加元素
	slice = append(slice,9,8,10,11) 
	fmt.Printf("slice的长度为：%v\t slice的容量为：%v\n",len(slice),cap(slice))
	fmt.Printf("新切片指向的地址：%p\n",&slice[0])
	fmt.Println("-----------------------------------------")

	//slice追加切片
	slice1 := []int{1,2,3}
	slice = append(slice,slice1...)
	fmt.Printf("追加slice的长度为：%v\t slice的容量为：%v\n",len(slice),cap(slice))
	fmt.Printf("新切片指向的地址：%p\n",&slice[0])

================切片动态增长===============
slice的长度为：3         slice的容量为：5
原切片指向的地址：0x140000b0008
-----------------------------------------
slice的长度为：7         slice的容量为：10
新切片指向的地址：0x140000b6000
-----------------------------------------
追加slice的长度为：10    slice的容量为：10
新切片指向的地址：0x140000b6000

PS：如果添加的元素超过原切片的容量，那么会创建新数组，且切片指向新的数组；如果没有超过原有切片的容量，那么，则会在原切片上增加元素，并且所引用的数组也会改变

package main 
import "fmt"
func main ()  {
	arr := [...]int{1,2,3,4,5,6}
	var slice []int
	slice = arr[1:4]
	//对切片进行切片
	slice2 := slice[1:2]

	fmt.Println(slice)
	fmt.Println(slice2)
	//改变二次切片的值，所有值都变
	slice2[0] = 9
	fmt.Println(slice)
	fmt.Println(slice2)

	//切片动态增长
	fmt.Println("================切片动态增长===============")
	fmt.Printf("slice的长度为：%v\t slice的容量为：%v\n",len(slice),cap(slice))
	fmt.Printf("原切片为：%v\n",slice)
	fmt.Printf("原数组为：%v\n",arr)

	fmt.Printf("原切片指向的地址：%p\n",&slice[0])
	fmt.Println("-----------------------------------------")

	//slice追加元素
	slice = append(slice,9,8) 
	fmt.Printf("slice的长度为：%v\t slice的容量为：%v\n",len(slice),cap(slice))
	fmt.Printf("新切片指向的地址：%p\n",&slice[0])
	fmt.Println("-----------------------------------------")
	fmt.Printf("新切片为：%v\n",slice)
	fmt.Printf("新数组为：%v\n",arr)
}

================切片动态增长===============
slice的长度为：3         slice的容量为：5
原切片为：[2 9 4]
原数组为：[1 2 9 4 5 6]
原切片指向的地址：0x140000b0008
-----------------------------------------
slice的长度为：5         slice的容量为：5
新切片指向的地址：0x140000b0008
-----------------------------------------
新切片为：[2 9 4 9 8]
新数组为：[1 2 9 4 9 8]

	//切片动态增长
	fmt.Println("================切片动态增长（超过切片容量）===============")
	fmt.Printf("slice的长度为：%v\t slice的容量为：%v\n",len(slice),cap(slice))
	fmt.Printf("原切片为：%v\n",slice)
	fmt.Printf("原数组为：%v\n",arr)

	fmt.Printf("原切片指向的地址：%p\n",&slice[0])
	fmt.Println("-----------------------------------------")

	//slice追加元素
	slice = append(slice,9,8,10) 
	fmt.Printf("slice的长度为：%v\t slice的容量为：%v\n",len(slice),cap(slice))
	fmt.Printf("新切片指向的地址：%p\n",&slice[0])
	fmt.Println("-----------------------------------------")
	fmt.Printf("新切片为：%v\n",slice)
	fmt.Printf("新数组为：%v\n",arr)

================切片动态增长（超过切片容量）===============
slice的长度为：3         slice的容量为：5
原切片为：[2 9 4]
原数组为：[1 2 9 4 5 6]
原切片指向的地址：0x140000b0008
-----------------------------------------
slice的长度为：6         slice的容量为：10
新切片指向的地址：0x140000b6050
-----------------------------------------
新切片为：[2 9 4 9 8 10]
新数组为：[1 2 9 4 5 6]

切片初始容量实际上是通过数组长度决定的，如果一个数组长度为6，切片从1开始切，则切片会留下剩下的数组长度作为容量

	arr := [...]int{1,2,3,4,5,6,7}
	var slice []int
	slice = arr[1:4]
	fmt.Printf("slice的长度为：%v\t slice的容量为：%v\n",len(slice),cap(slice))

slice的长度为：3         slice的容量为：6

	arr := [...]int{1,2,3,4,5,6}  //减少一个数组长度
	var slice []int
	slice = arr[1:4]
	fmt.Printf("slice的长度为：%v\t slice的容量为：%v\n",len(slice),cap(slice))

slice的长度为：3         slice的容量为：6

所以着也能解释为什么使用slice := []int{1,2,3,4}这样定义slice，其长度为4，因为数组的长度只有4，且此处，引用的整个数组。

  1. 切片的拷贝——copy函数
    请添加图片描述
//切片拷贝
	fmt.Println("================切片拷贝===============")
	//创建新的切片空间
	slice3 := make([]int,10)
	//拷贝slice
	copy(slice3,slice)
	fmt.Println(slice3)

================切片拷贝===============
[2 9 4 9 8 10 0 0 0 0]
Dearfrienda
关注
  • 19
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
golang 击破slice中append陷阱
m0_38023144的博客
09-19 740
golang函数中切片使用append函数的一些陷阱
Go Slice与append原理
一只Coding猪
06-03 1882
一. 引言 最早在go设计的初期，设计者们花了一年的时间对array类型的定义进行讨论，因为像其他语言一样，数组一般被设计为定长的、长度属于类型的一部分的用来描述线性地址空间的数据结构，但是这种定长类型对于使用者比较受局限，所以类似像C++这样的语言会出现vector这样的数据结构，来弥补数组在动态特征方面的不足。go语言的设计者不希望对array进行差别定义，这样会增加其他语言迁移过来的学习者的理解成本，同时也不希望放弃线性数据结构的动态化特性，所以引入了slice这一概念，这就是slice的诞生背景。
Go 切片在函数传递时，在函数内对传递的切片进行 append，会创建一个新的切片
最新发布
wgchen
04-29 204
Go 切片在函数传递时，在函数内对传递的切片进行 append，会创建一个新的切片
Golang中Slice的append详解
weixin_34327223的博客
09-05 246
本文原创文章,转载注明出处,博客地址 https://segmentfault.com/u/to... 第一时间看后续精彩文章。觉得好的话,顺手分享到朋友圈吧,感谢支持。 在Golang语言中,数据类型不多,但是够用,开发项目过程中,Slice属于最常用的数据结构之一,对其原理理解不清楚,很容易会遗留bug,笔者查询了很多博客资料,对Sl...
Go语言之重要数组类型切片（slice）make，append函数
凯歌技术控团队
07-16 1001
切片是一个动态数组，因为数组的长度是固定的，所以操作起来很不方便，比如一个names数组，我想增加一个学生姓名都没有办法，十分不灵活。所以在开发中数组并不常用，切片类型才是大量使用的。
[Golang]再谈slice切片与append
m0_38059938的博客
11-17 1361
在浏览studygolang的一篇帖子时，发现楼主提出了一个slice与append的问题，我一寻思，这玩意儿我之前研究过一会儿，肯定能解答，然后还没敲5个字就发现我也不明白了，然后再次去研究了一遍，终于觉得自己理解了，现在记录一下。 首先放出原帖子的代码： package main import "fmt" func main() { arr := make([]int, 3, 4) //创建一个长度为 ...
golang slice的追加：append
weixin_42228815的博客
04-18 1017
golang 中 append 函数
golang常用手册之切片(Slice)原理
09-20
fmt.Printf("切片slice_name的长度：len=%d cap=%d\n", len(sliceName), cap(sliceName)) ``` **初始化切片** 切片可以通过数组初始化，如 `arr := []int{1, 2, 3}`。然后，通过数组的切片操作 `arr[:]` 来创建...
Golang slice切片操作之切片的追加、删除、插入等
12-25
本文介绍了Golang slice切片操作之切片的追加、删除、插入等，分享给大家，具体如下： 一、一般操作 1,声明变量，go自动初始化为nil，长度：0，地址：0，nil func main(){ var ss []string; fmt.Printf("length:%...
浅谈golang slice 切片原理
09-21
如果需要预分配容量，可以使用`make`函数，如`s := make([]int, 10, 20)`，这里创建了一个长度为10、容量为20的`slice`，意味着它可以容纳10个初始元素，并且在不重新分配的情况下还能追加10个元素。 `slice`的长度...
golang源码分析–slice
01-08
(注意:切片传递的是指针的拷贝值，所以可以在函数里面修改指针指向的值，对外有影响) 切片的自动增长是通过append()函数来实现的 切片的底层内存也是在连续块中分配的，所以切片还能获得索引，迭代以及为垃圾回收...
Go_切片初始化、遍历、截取、修改、append、copy、作为函数参数、求和、求最大值
itzhuzhu的博客
01-27 6165
切片的长度是不固定的，可以追加数据，类似于Java中的动态数组的概念吧，切片出现的原因也是因为数组的可操作性不高。
golang中apend_Golang中Slice的append详解
weixin_39844267的博客
12-22 327
我说下我的看法：1. 首先定义的这个slice变量s在内存中就是一个长度为1的数组，里边只有一个元素为5.(注意数组是不可变的)2. 如果向s上增加一个新的元素，由于数组不可变，需要生成一个新的数组，长度为2，让s指向这个新的数组，这样才能将新的数据加入，这个时候将7加入；3. 另外，由于slice容量不够，每次扩容都会自动扩大为之前的2倍，之前是从1变为2；4. 当再次向s中增加元素的时候，2又...
golang 切片 append 扩容性能分析
小知识折射大智慧
09-01 1242
很多时候，我们对这个功能点不够重视，经常也会写一些没有声明 cap 容量的变量声明，然后直接调用 append，逻辑上是没有问题的，但是当 append 的数量足够多的时候，性能问题就突出来了。
golang在函数中对slice进行append操作不影响外部的值
shade7的博客
03-06 414
golang在函数中对slice进行append操作不影响外部的值
go语言基础，切片的append原理
qq_21154829的博客
11-01 2421
Go 切片的 append 操作总结 预备 切片是对其底层数组的某一段的引用。 切片有 len 和 cap 两个属性，代表切片的引用长度和切片的容量（从切片的引用起点位置到其底层数组最末端的长度。因为其底层数组的长度是固定的，这也就是意味着容量是指切片可引用的最大宽度）。 append 函数 slice2 := append(slice1, 23, 15) 以上对切片 slice1 进行 append 操作。该操作遵循以下原则： append 函数对一个切片 slice1 进行追加操作，并返回另一个长度为
【Golang】切片的底层实现（关于slice调用append函数后分配新数组的问题）
polarday的博客
12-09 2007
切片的底层实现，len，cap，切片的len超过cap之后系统会分配新的数组
Golang基础-切片
一起学习吧
10-14 465
切片 文章目录切片1.切片的引入2.内存分析3.切片的定义4.切片的遍历5.切片的注意事项 1.切片的引入 【1】切片(slice)是golang中一种特有的数据类型 【2】数组有特定的用处，但是却有一些呆板(数组长度固定不可变)，所以在 Go 语言的代码里并不是特别常见。相对的切片却是随处可见的，切片是一种建立在数组类型之上的抽象，它构建在数组之上并且提供更强大的能力和便捷。 【3】切片(slice)是对数组一个连续片段的引用，所以切片是一个引用类型。这个片段可以是整个数组，或者是由起始和终止索引标识的一
go语言slice剖析 | 切片详解
ThinPikachu的博客
07-28 591
目录 1. 前言 2. 热身环节 2.1 题目一 2.2 题目二 2.3 题目三 3. Slice实现原理 3.1 Slice数据结构 3.2 使用make创建Slice 3.3 使用数组创建Slice 3.4 Slice 扩容 3.5 Slice Copy 3.5 特殊切片 4. 编程Tips 5. Slice总结 1. 前言 Slice又称动态数组，依托数组实现，可以方便的进行扩容、传递等，实际使用中比数组更灵活。 正因为灵活，如果不了解其内部实现机制，有可能遭遇莫名的
golang append追加一个切片
05-26
可以使用`append`函数在一个切片后追加另一个切片。例如： ```go slice1 := []int{1, 2, 3} slice2 := []int{4, 5, 6} slice1 = append(slice1, slice2...) fmt.Println(slice1) // 输出 [1 2 3 4 5 6] ``` 需要注意的是，使用`append`函数追加切片时，需要在第二个切片的后面加上`...`，表示将切片打散为单个元素逐个追加。如果不加`...`，会导致编译错误，提示类型不匹配。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值