在这里插入图片描述

🌷 博主 libin9iOak带您 Go to Golang Language.✨
🦄 个人主页——libin9iOak的博客🎐
🐳 《面试题大全》文章图文并茂🦕生动形象🦖简单易学！欢迎大家来踩踩~🌺
🌊 《IDEA开发秘籍》学会IDEA常用操作，工作效率翻倍~💐
🪁 希望本文能够给您带来一定的帮助🌸文章粗浅，敬请批评指正！🐥

100天精通Golang（基础入门篇）

摘要：
前言：
100天精通Golang（基础入门篇）——第11天：深入解析Go语言中的切片(Slice)及常用函数应用
一、切片(Slice)
- 1.1 什么是切片?
- 1.2 切片的语法
- 1.3 修改切片
- 1.4 len() 和 cap() 函数
- 1.5 append() 和 copy() 函数
- - append()函数
  - copy() 函数
- 代码案例总结
- - 代码案例1
  - 代码案例2:
  - 代码案例3:
  - 代码案例4:
  - 代码案例5:
- 今日学习总结：
结语

摘要：

本文是《100天精通Golang（基础入门篇）——第11天：切片(Slice)》，将详细介绍切片的概念、语法、修改、以及len()、cap()、append()和copy()函数的使用。读者将通过学习本文深入了解Golang中切片的使用方法和常用函数的功能。

前言：

切片（Slice）是Golang中非常重要的数据结构，它可以动态地调整大小，并且常用于处理集合的情况。在本文中，我们将系统地介绍切片的概念、语法和修改方式，并逐一讲解len()、cap()、append()和copy()函数的用法。通过学习本文，读者将更加熟悉切片的操作，提高对Golang的掌握程度。

100天精通Golang（基础入门篇）——第11天：深入解析Go语言中的切片(Slice)及常用函数应用

一、切片(Slice)

在Golang中，切片（Slice）是一种灵活、动态大小的数据结构，能够方便地处理集合类型的数据。通过切片，我们可以轻松地操作数组或其他切片，实现对数据的增删改查等操作。

1.1 什么是切片?

Go 语言切片是对数组的抽象。
Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片(“动态数组”),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大切片是一种方便、灵活且强大的包装器。切片本身没有任何数据。它们只是对现有数组的引用。

切片与数组相比，不需要设定长度，在[]中不用设定值，相对来说比较自由

从概念上面来说slice像一个结构体，这个结构体包含了三个元素：

指针，指向数组中slice指定的开始位置
长度，即slice的长度
最大长度，也就是slice开始位置到数组的最后位置的长度

小结： 切片可以理解为对数组的一个引用，它由指向数组的指针、切片的长度和切片的容量组成。切片的长度表示切片中实际存储的元素个数，而容量表示切片底层数组的大小。切片相比于数组的优势在于它的大小是动态可变的，可以根据需要进行扩容或缩减。

1.2 切片的语法

在Golang中，切片的语法很简洁，使用方括号[ ]来声明一个切片，并指定切片的长度或容量。例如：

var slice []int             // 声明一个切片
slice := make([]int, 0)     // 创建一个切片，并指定长度为0

通过索引访问切片中的元素与数组类似，但切片可以动态地调整大小。

定义切片

var identifier []type

切片不需要说明长度。
或使用make()函数来创建切片:

var slice1 []type = make([]type, len)
也可以简写为
slice1 := make([]type, len)

make([]T, length, capacity)

初始化

s[0] = 1
s[1] = 2
s[2] = 3

s :=[] int {1,2,3 }

s := arr[startIndex:endIndex]

将arr中从下标startIndex到endIndex-1 下的元素创建为一个新的切片（前闭后开），长度为endIndex-startIndex

s := arr[startIndex:]

缺省endIndex时将表示一直到arr的最后一个元素

s := arr[:endIndex]

缺省startIndex时将表示从arr的第一个元素开始

package main

import (  
    "fmt"
)

func main() {  
    a := [5]int{76, 77, 78, 79, 80}
    var b []int = a[1:4] //creates a slice from a[1] to a[3]
    fmt.Println(b)
}

1.3 修改切片

对切片进行修改非常方便，可以通过索引进行赋值或修改现有元素的值。此外，还可以使用切片作为参数传递给某个函数，并在函数内部对切片进行修改。这种特性使得切片在处理大量数据时非常高效。

slice没有自己的任何数据。它只是底层数组的一个表示。对slice所做的任何修改都将反映在底层数组中。

示例代码：

package main

import (  
    "fmt"
)

func main() {  
    darr := [...]int{57, 89, 90, 82, 100, 78, 67, 69, 59}
    dslice := darr[2:5]
    fmt.Println("array before",darr)
    for i := range dslice {
        dslice[i]++
    }
    fmt.Println("array after",darr) 
}

运行结果：

array before [57 89 90 82 100 78 67 69 59]  
array after [57 89 91 83 101 78 67 69 59]

当多个片共享相同的底层数组时，每个元素所做的更改将在数组中反映出来。

示例代码：

package main

import (  
    "fmt"
)

func main() {  
    numa := [3]int{78, 79 ,80}
    nums1 := numa[:] //creates a slice which contains all elements of the array
    nums2 := numa[:]
    fmt.Println("array before change 1",numa)
    nums1[0] = 100
    fmt.Println("array after modification to slice nums1", numa)
    nums2[1] = 101
    fmt.Println("array after modification to slice nums2", numa)
}

运行结果：

array before change 1 [78 79 80]  
array after modification to slice nums1 [100 79 80]  
array after modification to slice nums2 [100 101 80]

1.4 len() 和 cap() 函数

Golang提供了两个内置函数len()和cap()来获取切片的长度和容量。len()函数返回切片中实际存储的元素个数，而cap()函数返回切片底层数组的大小。这两个函数的使用非常简单，直接对切片调用即可。

切片的长度是切片中元素的数量。切片的容量是从创建切片的索引开始的底层数组中元素的数量。

切片是可索引的，并且可以由 len() 方法获取长度
切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少

package main

import "fmt"

func main() {
   var numbers = make([]int,3,5)

   printSlice(numbers)
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

运行结果

len=3 cap=5 slice=[0 0 0]

空切片

一个切片在未初始化之前默认为 nil，长度为 0

package main

import "fmt"

func main() {
   var numbers []int

   printSlice(numbers)

   if(numbers == nil){
      fmt.Printf("切片是空的")
   }
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

运行结果

len=0 cap=0 slice=[]
切片是空的

package main

import "fmt"

func main() {
   /* 创建切片 */
   numbers := []int{0,1,2,3,4,5,6,7,8}   
   printSlice(numbers)

   /* 打印原始切片 */
   fmt.Println("numbers ==", numbers)

   /* 打印子切片从索引1(包含) 到索引4(不包含)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])

   /* 默认下限为 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])

   /* 默认上限为 len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])

   numbers1 := make([]int,0,5)
   printSlice(numbers1)

   /* 打印子切片从索引  0(包含) 到索引 2(不包含) */
   number2 := numbers[:2]
   printSlice(number2)

   /* 打印子切片从索引 2(包含) 到索引 5(不包含) */
   number3 := numbers[2:5]
   printSlice(number3)

}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

运行结果

len=9 cap=9 slice=[0 1 2 3 4 5 6 7 8]
numbers == [0 1 2 3 4 5 6 7 8]
numbers[1:4] == [1 2 3]
numbers[:3] == [0 1 2]
numbers[4:] == [4 5 6 7 8]
len=0 cap=5 slice=[]
len=2 cap=9 slice=[0 1]
len=3 cap=7 slice=[2 3 4]

小结：

len()函数返回切片中实际存储的元素个数。也就是说，它告诉我们这个切片中有多少个元素。比如，如果我们有一个切片slice，那么通过len(slice)就可以得到它的长度。这对于我们在遍历切片或进行其他操作时非常有用。

cap()函数则返回切片底层数组的大小，也就是切片的容量。容量是指切片底层数组的总大小，而实际存储的元素个数可能小于或等于容量。因此，当我们使用append()函数向切片中添加元素时，如果超出了切片的容量，则底层数组会自动进行扩容。此时，我们就可以通过cap()函数来查看切片的容量是否发生了改变。

使用这两个函数可以帮助我们更好地了解和管理切片的大小和容量。比如，我们可以使用len()函数来判断切片是否为空，即长度为0；使用cap()函数可以了解切片当前的容量是否满足需求，是否需要进行扩容操作。

需要注意的是，len()和cap()函数只能用于切片和数组，并且只能对第一维度的长度和容量进行计算。如果我们有一个切片的切片，那么len()函数将返回第一维度的长度，而不会返回第二维度的长度。

总之，len()函数和cap()函数是Golang提供的两个非常有用的函数，它们可以帮助我们更好地了解和管理切片的大小和容量。在切片的使用过程中，记得经常使用它们，以便更好地利用切片的特性。

1.5 append() 和 copy() 函数

append()函数用于向切片中添加元素，可以一次添加一个或多个元素。如果切片的容量不足以容纳新添加的元素，append()函数会自动进行扩容操作。

append()函数

用于向切片中添加元素。它的功能非常强大，可以一次添加一个或多个元素。append()函数接受两个参数：第一个参数是要添加元素的切片，第二个参数是要添加的元素。添加完元素后，append()函数会返回一个新的切片，我们通常需要将其赋值给原始的切片。

除了添加元素，append()函数还有一个重要的功能——动态扩容。当切片的容量不足以容纳新添加的元素时，append()函数会自动进行扩容操作。它会创建一个新的底层数组，并将原始数据复制到新数组中。然后，它会将新添加的元素放入新数组中，并返回一个新的切片。这样，我们就可以使用扩容后的切片了。

需要注意的是，由于append()函数会创建一个新的底层数组并进行数据复制，因此在大量使用append()函数时，可能会带来一些性能开销。所以，在预知切片大小的情况下，最好提前指定好切片的容量，以减少扩容的次数。

copy() 函数

copy()函数用于将一个切片的内容复制到另一个切片中。这对于切片的复制和拷贝操作非常方便。copy()函数接受两个参数：第一个参数是目标切片，第二个参数是源切片。copy()函数会将源切片中的元素复制到目标切片中，并返回复制的元素个数。

与append()函数不同，copy()函数不会进行扩容操作。它仅将源切片中的元素按照顺序复制到目标切片中。因此，需要注意两个切片的大小要一致，否则可能会造成数据丢失或越界访问。

需要特别注意的是，在使用copy()函数时，切片的容量不会发生改变。目标切片的容量还是保持不变，因此，如果目标切片容量不足以容纳源切片，可能会导致部分数据丢失。

演示案例：

copy()函数用于将一个切片的内容复制到另一个切片中，非常方便实现切片的复制和拷贝操作。

append 向slice里面追加一个或者多个元素，然后返回一个和slice一样类型的slice
copy 函数copy从源slice的src中复制元素到目标dst，并且返回复制的元素的个数

append函数会改变slice所引用的数组的内容，从而影响到引用同一数组的其它slice。但当slice中没有剩
余空间（即(cap-len) == 0）时，此时将动态分配新的数组空间。返回的slice数组指针将指向这个空间，而原
数组的内容将保持不变；其它引用此数组的slice则不受影响

下面的代码描述了从拷贝切片的 copy 方法和向切片追加新元素的 append 方法

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)

   /* 允许追加空切片 */
   numbers = append(numbers, 0)
   printSlice(numbers)

   /* 向切片添加一个元素 */
   numbers = append(numbers, 1)
   printSlice(numbers)

   /* 同时添加多个元素 */
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)

   /* 创建切片 numbers1 是之前切片的两倍容量*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)

   /* 拷贝 numbers 的内容到 numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

运行结果

len=0 cap=0 slice=[]
len=1 cap=2 slice=[0]
len=2 cap=2 slice=[0 1]
len=5 cap=8 slice=[0 1 2 3 4]
len=5 cap=12 slice=[0 1 2 3 4]

numbers1与numbers两者不存在联系，numbers发生变化时，numbers1是不会随着变化的。也就是说copy方法是不会建立两个切片的联系的

代码案例总结

代码案例1

package main

import "fmt"

func main() {
	/*
		数组array：
			存储一组相同数据类型的数据结构。
				特点：定长

		切片slice：
			同数组类似，也叫做变长数组或者动态数组。
				特点：变长

			是一个引用类型的容器，指向了一个底层数组。

		make()
			func make(t Type, size ...IntegerType) Type

			第一个参数：类型
				slice，map，chan
			第二个参数：长度len
				实际存储元素的数量
			第三个参数：容量cap
				最多能够存储的元素的数量


		append()，专门用于向切片的尾部追加元素
			slice = append(slice, elem1, elem2)
			slice = append(slice, anotherSlice...)
	*/
	//1.数组
	arr := [4]int{1, 2, 3, 4} //定长
	fmt.Println(arr)

	//2.切片
	var s1 []int
	fmt.Println(s1)

	s2 := []int{1, 2, 3, 4} //变长
	fmt.Println(s2)
	fmt.Printf("%T,%T\n", arr, s2) //[4]int,[]int

	s3 := make([]int, 3, 8)
	fmt.Println(s3)
	fmt.Printf("容量：%d,长度：%d\n", cap(s3), len(s3))
	s3[0] = 1
	s3[1] = 2
	s3[2] = 3
	fmt.Println(s3)
	//fmt.Println(s3[3]) //panic: runtime error: index out of range

	//append()
	s4 := make([]int, 0, 5)
	fmt.Println(s4)
	s4 = append(s4, 1, 2)
	fmt.Println(s4)
	s4 = append(s4, 3, 4, 5, 6, 7)
	fmt.Println(s4)

	s4 = append(s4, s3...)
	fmt.Println(s4)

	//遍历切片
	for i := 0; i < len(s4); i++ {
		fmt.Println(s4[i])
	}

	for i, v := range s4 {
		fmt.Printf("%d-->%d\n", i, v)
	}

}

运行结果:

GOROOT=D:\Go #gosetup
GOPATH=C:\Users\DELL\go #gosetup
D:\Go\bin\go.exe build -o C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day11_Slice.exe Day11-Slice #gosetup
C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day11_Slice.exe
[1 2 3 4]
[]
[1 2 3 4]
[4]int,[]int
[0 0 0]
容量：8,长度：3
[1 2 3]
[]
[1 2]
[1 2 3 4 5 6 7]
[1 2 3 4 5 6 7 1 2 3]
1
2
3
4
5
6
7
1
2
3
0-->1
1-->2
2-->3
3-->4
4-->5
5-->6
6-->7
7-->1
8-->2
9-->3

进程 已完成，退出代码为 0

运行截图:

在这里插入图片描述

代码案例2:


package main

import "fmt"

func main() {
	/*
		切片Slice：
			1.每一个切片引用了一个底层数组
			2.切片本身不存储任何数据，都是这个底层数组存储，所以修改切片也就是修改这个数组中的数据
			3.当向切片中添加数据时，如果没有超过容量，直接添加，如果超过容量，自动扩容(成倍增长)
			4.切片一旦扩容，就是重新指向一个新的底层数组

		s1:3--->6--->12--->24

		s2:4--->8--->16--->32....

	*/
	s1 := []int{1, 2, 3}
	fmt.Println(s1)
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1)) //len:3,cap:3
	fmt.Printf("%p\n", s1)

	s1 = append(s1, 4, 5)
	fmt.Println(s1)
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1)) //len:5,cap:6
	fmt.Printf("%p\n", s1)

	s1 = append(s1, 6, 7, 8)
	fmt.Println(s1)
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1)) //len:8,cap:12
	fmt.Printf("%p\n", s1)

	s1 = append(s1, 9, 10)
	fmt.Println(s1)
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1)) //len:10,cap:12
	fmt.Printf("%p\n", s1)

	s1 = append(s1, 11, 12, 13, 14, 15)
	fmt.Println(s1)
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1)) //len:15,cap:24
	fmt.Printf("%p\n", s1)
}

运行结果:

GOROOT=D:\Go #gosetup
GOPATH=C:\Users\DELL\go #gosetup
D:\Go\bin\go.exe build -o C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day11_Slice__1_.exe D:\GolandProjects\Day11-Slice\Slice2.go #gosetup
C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day11_Slice__1_.exe
[1 2 3]
len:3,cap:3
0xc000010180
[1 2 3 4 5]
len:5,cap:6
0xc00000e360
[1 2 3 4 5 6 7 8]
len:8,cap:12
0xc000060120
[1 2 3 4 5 6 7 8 9 10]
len:10,cap:12
0xc000060120
[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15]
len:15,cap:24
0xc00007e000

进程 已完成，退出代码为 0

运行截图:

在这里插入图片描述

代码案例3:

package main

import "fmt"

func main() {
	/*
		slice := arr[start:end]
		 	切片中的数据：[start,end)
		 	arr[:end],从头到end
		 	arr[start:]从start到末尾

		 从已有的数组上，直接创建切片，该切片的底层数组就是当前的数组。
		 	长度是从start到end切割的数据量。
			但是容量从start到数组的末尾。
	*/
	a := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	fmt.Println("----------1.已有数组直接创建切片--------------------")
	s1 := a[:5]  //1-5
	s2 := a[3:8] //4-8
	s3 := a[5:]  // 6-10
	s4 := a[:]   // 1-10
	fmt.Println("a:", a)
	fmt.Println("s1:", s1)
	fmt.Println("s2:", s2)
	fmt.Println("s3:", s3)
	fmt.Println("s4:", s4)

	fmt.Printf("%p\n", &a)
	fmt.Printf("%p\n", s1)

	fmt.Println("----------2.长度和容量--------------------")
	fmt.Printf("s1	len:%d,cap:%d\n", len(s1), cap(s1)) //s1	len:5,cap:10
	fmt.Printf("s2	len:%d,cap:%d\n", len(s2), cap(s2)) //s2	len:5,cap:7
	fmt.Printf("s3	len:%d,cap:%d\n", len(s3), cap(s3)) //s3	len:5,cap:5
	fmt.Printf("s4	len:%d,cap:%d\n", len(s4), cap(s4)) //s4	len:10,cap:10

	fmt.Println("----------3.更改数组的内容--------------------")
	a[4] = 100
	fmt.Println(a)
	fmt.Println(s1)
	fmt.Println(s2)
	fmt.Println(s3)

	fmt.Println("----------4.更改切片的内容--------------------")
	s2[2] = 200
	fmt.Println(a)
	fmt.Println(s1)
	fmt.Println(s2)
	fmt.Println(s3)

	fmt.Println("----------4.更改切片的内容--------------------")
	s1 = append(s1, 1, 1, 1, 1)
	fmt.Println(a)
	fmt.Println(s1)
	fmt.Println(s2)
	fmt.Println(s3)
	fmt.Println("----------5.添加元素切片扩容--------------------")
	fmt.Println(len(s1), cap(s1))

	s1 = append(s1, 2, 2, 2, 2, 2)
	fmt.Println(a)
	fmt.Println(s1)
	fmt.Println(s2)
	fmt.Println(s3)
	fmt.Println(len(s1), cap(s1))
	fmt.Printf("%p\n", s1)
	fmt.Printf("%p\n", &a)
}

运行结果:


GOROOT=D:\Go #gosetup
GOPATH=C:\Users\DELL\go #gosetup
D:\Go\bin\go.exe build -o C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day11_Slice__2_.exe D:\GolandProjects\Day11-Slice\Slice3.go #gosetup
C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day11_Slice__2_.exe
----------1.已有数组直接创建切片--------------------
a: [1 2 3 4 5 6 7 8 9 10]
s1: [1 2 3 4 5]
s2: [4 5 6 7 8]
s3: [6 7 8 9 10]
s4: [1 2 3 4 5 6 7 8 9 10]
0xc000018190
0xc000018190
----------2.长度和容量--------------------
s1      len:5,cap:10
s2      len:5,cap:7
s3      len:5,cap:5
s4      len:10,cap:10
----------3.更改数组的内容--------------------
[1 2 3 4 100 6 7 8 9 10]
[1 2 3 4 100]
[4 100 6 7 8]
[6 7 8 9 10]
----------4.更改切片的内容--------------------
[1 2 3 4 100 200 7 8 9 10]
[1 2 3 4 100]
[4 100 200 7 8]
[200 7 8 9 10]
----------4.更改切片的内容--------------------
[1 2 3 4 100 1 1 1 1 10]
[1 2 3 4 100 1 1 1 1]
[4 100 1 1 1]
[1 1 1 1 10]
----------5.添加元素切片扩容--------------------
9 10
[1 2 3 4 100 1 1 1 1 10]
[1 2 3 4 100 1 1 1 1 2 2 2 2 2]
[4 100 1 1 1]
[1 1 1 1 10]
14 20
0xc0000240a0
0xc000018190

进程 已完成，退出代码为 0

运行截图:

在这里插入图片描述

代码案例4:

package main

import "fmt"

func main() {
	/*

		按照类型来分：
			基本类型：int，float，string，bool
			复合类型：array，slice，map，struct，pointer，function，chan

		按照特点来分：
			值类型：int，float，string，bool，array
				传递的是数据副本
			引用类型：Slice
				传递的地址,多个变量指向了同一块内存地址，



		所以：切片是引用类型的数据，存储了底层数组的引用
	*/

	//1.数组：值类型
	a1 := [4]int{1, 2, 3, 4}
	a2 := a1 //值传递：传递的是数据
	fmt.Println(a1, a1)
	a1[0] = 100
	fmt.Println(a1, a2)

	//2.切片：引用类型
	s1 := []int{1, 2, 3, 4}
	s2 := s1
	fmt.Println(s1, s2)
	s1[0] = 100
	fmt.Println(s1, s2)

	fmt.Printf("%p\n", s1)
	fmt.Printf("%p\n", s2)
	fmt.Printf("%p\n", &s1)
	fmt.Printf("%p\n", &s2)

	//1. `fmt.Printf("%p\n", s1)`：这行代码中的`%p`是格式化字符串，用于打印指针的值。`s1`是一个变量，通过使用`%p`格式化字符串，我们可以打印出`s1`变量的内存地址。

	//2. `fmt.Printf("%p\n", s2)`：同样地，这行代码用于打印`s2`变量的内存地址。通过使用`%p`格式化字符串，我们可以获取`s2`变量的内存地址。

	//	3. `fmt.Printf("%p\n", &s1)`：这行代码中的`&`符号用于获取`s1`变量的地址。然后，通过使用`%p`格式化字符串，我们可以将`s1`变量的地址打印出来。

	//4. `fmt.Printf("%p\n", &s2)`：同样地，这行代码用于打印`s2`变量的地址。通过使用`%p`格式化字符串，我们可以获取`s2`变量的地址。

}

运行结果:


GOROOT=D:\Go #gosetup
GOPATH=C:\Users\DELL\go #gosetup
D:\Go\bin\go.exe build -o C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day11_Slice__3_.exe D:\GolandProjects\Day11-Slice\Slice4.go #gosetup
C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day11_Slice__3_.exe
[1 2 3 4] [1 2 3 4]
[100 2 3 4] [1 2 3 4]
[1 2 3 4] [1 2 3 4]
[100 2 3 4] [100 2 3 4]
0xc000012200
0xc000012200
0xc000008078
0xc000008090

进程 已完成，退出代码为 0

运行截图:

在这里插入图片描述

代码案例5:


package main

import "fmt"

func main() {
	/*
		深拷贝：拷贝的是数据本身。
			值类型的数据，默认都是深拷贝：array，int，float，string，bool，struct


		浅拷贝：拷贝的是数据 地址。
			导致多个变量指向同一块内存
			引用类型的数据，默认都是浅拷贝：slice，map，

			因为切片是引用类型的数据，直接拷贝的是地址。

		func copy(dst, src []Type) int
			可以实现切片的拷贝

	*/

	s1 := []int{1, 2, 3, 4}
	s2 := make([]int, 0) //len:0,cap:0
	for i := 0; i < len(s1); i++ {
		s2 = append(s2, s1[i])
	}
	fmt.Println(s1)
	fmt.Println(s2)

	s1[0] = 100
	fmt.Println(s1)
	fmt.Println(s2)

	//copy()
	s3 := []int{7, 8, 9}
	fmt.Println(s2)
	fmt.Println(s3)

	//copy(s2,s3) //将s3中的元素，拷贝到s2中
	//copy(s3,s2) //将s2中的元素，拷贝到s3中
	copy(s3[1:], s2[2:])

	//[1:] 和 [2:] 表示切片的切片操作，用于指定切片的起始位置。在这个例子中，[1:] 表示将目标切片的起始位置从索引1开始（即去掉了第一个元素），[2:] 表示将源切片的起始位置从索引2开始（即去掉了前两个元素）。
	fmt.Println(s2)
	fmt.Println(s3)

	//copy(s3[1:], s2[2:]) 的作用是将源切片 s2 中从索引2开始（包括索引2）的元素复制到目标切片 s3 中，从索引1开始（包括索引1）的位置开始填充。

}

运行结果:

GOROOT=D:\Go #gosetup
GOPATH=C:\Users\DELL\go #gosetup
D:\Go\bin\go.exe build -o C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day11_Slice__4_.exe D:\GolandProjects\Day11-Slice\Slice5.go #gosetup
C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day11_Slice__4_.exe
[1 2 3 4]
[1 2 3 4]
[100 2 3 4]
[1 2 3 4]
[1 2 3 4]
[7 8 9]
[1 2 3 4]
[7 3 4]

进程 已完成，退出代码为 0

运行截图:

在这里插入图片描述

今日学习总结：

今天我学习了Golang中的切片（Slice），通过本文的学习，我深入了解了切片的概念、语法以及常用函数的使用。我学会了如何修改切片、获取切片的长度和容量，并掌握了append()和copy()函数的功能和应用场景。切片是Golang中非常重要的数据结构，对于提高代码的灵活性和效率有着重要的作用。希望本文能够帮助读者加深对切片的理解和应用。

通过学习本篇文章，希望读者了解了切片的概念、语法以及基本操作的使用方式。掌握了len()、cap()、append()和copy()等常用函数的功能和使用方法。切片在Golang中的应用非常广泛，对于大数据集合的处理以及动态扩容等场景非常实用。切片的灵活性和效率使得它成为Golang中重要的数据结构之一。如果你对Golang的切片还有更多的疑问，可以继续学习Golang的高级切片特性或查阅相关的官方文档。祝你在Golang的切片世界中玩得开心！

在这里插入图片描述