100天精通Golang（基础入门篇）——第11天：深入解析Go语言中的切片(Slice)及常用函数应用
100天精通Golang（基础入门篇）——第11天：深入解析Go语言中的切片(Slice)及常用函数应用
摘要：
本文是《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] = 3s :=[] 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的切片世界中玩得开心！
结语
通过今天的学习，您已经踏上了Golang的学习之旅。在未来的日子里，您将探索Golang的各个方面，从基础概念到高级技巧，从实际应用到性能优化。 学习一门编程语言是一个持续的过程，每一天都是您向Golang的精通迈进的重要一步。我鼓励您坚持每天学习，保持热情和好奇心，解决挑战并享受成功的喜悦。
在您的学习旅程中，不要忘记参与社区和与其他Golang开发者交流。分享您的见解和经验，向他人学习，并在开源项目或实际应用中展示您的技能。
如果您在学习过程中遇到困难或有任何问题，不要犹豫向社区和专家寻求帮助。持续学习，勇敢探索，您将在Golang领域取得令人瞩目的成就。
最后，感谢您的阅读和支持！祝愿您在未来的每一天中都能够成为一名精通Golang的开发者！
期待听到您在学习过程中的进展和成就。如果您需要进一步的帮助，请随时告诉我。祝您在学习Golang的旅程中取得巨大成功！