Dalam bahasa Go, hirisan ialah rujukan kepada serpihan berterusan tatasusunan, jadi serpihan ialah jenis rujukan ini boleh menjadi keseluruhan tatasusunan, atau ia boleh dikenal pasti melalui permulaan dan akhir indeks. Subset beberapa item taburan memori bagi kepingan adalah berterusan, jadi kepingan boleh dianggap sebagai tatasusunan saiz berubah. Keratan ialah struktur data dengan tiga medan: penunjuk kepada tatasusunan asas, bilangan elemen yang diakses oleh kepingan (iaitu, panjang) dan bilangan elemen yang dibenarkan untuk berkembang menjadi kepingan (iaitu kapasiti).
Persekitaran pengendalian tutorial ini: sistem Windows 7, GO versi 1.18, komputer Dell G3.
Sekian ialah rujukan kepada serpihan bersebelahan tatasusunan, jadi hirisan ialah jenis rujukan (dan oleh itu lebih serupa dengan jenis tatasusunan dalam C/C++, atau jenis senarai dalam Python ini). boleh Ia adalah keseluruhan tatasusunan, atau ia boleh menjadi subset beberapa item yang dikenal pasti oleh indeks permulaan dan akhir Perlu diingatkan bahawa item yang dikenal pasti oleh indeks akhir tidak termasuk dalam kepingan.
Struktur dalaman hirisan dalam bahasa Go termasuk alamat, saiz dan kapasiti Kepingan biasanya digunakan untuk mengendalikan set data dengan cepat Jika set data dibandingkan dengan memotong kek, sekeping adalah "kepingan". anda mahu. , proses pemotongan termasuk di mana untuk bermula (kedudukan permulaan kepingan) dan berapa besar untuk dipotong (saiz kepingan boleh difahami sebagai saiz poket yang memegang kepingan, seperti yang ditunjukkan dalam rajah di bawah.
Rajah: Struktur kepingan dan peruntukan memori
Pengagihan memori kepingan adalah berterusan, jadi anda boleh menganggap kepingan itu sebagai susunan saiz tidak tetap.
Sepotong mempunyai struktur data dengan tiga medan Struktur data ini mengandungi metadata yang diperlukan oleh bahasa Go pada tatasusunan asas ini adalah penunjuk kepada tatasusunan asas dan bilangan elemen yang diakses oleh hirisan (iaitu panjang ) dan bilangan unsur (iaitu kapasiti) hirisan dibenarkan untuk membesar. Perbezaan antara panjang dan kapasiti akan dijelaskan kemudian.
Sekeping menghala ke kawasan memori berterusan secara lalai, yang boleh tatasusunan atau kepingan itu sendiri.
Menjana kepingan daripada kawasan memori berterusan ialah operasi biasa Formatnya adalah seperti berikut:
slice [开始位置 : 结束位置]
Sintaks adalah seperti berikut:
var a = [3]int{1, 2, 3}
fmt.Println(a, a[1:2])Menjana kepingan baharu daripada tatasusunan atau kepingan mempunyai ciri-ciri berikut:
[1 2 3] [2]
Keluaran kod adalah seperti berikut:
<🎜. >Bangunan bertingkat 30 tingkat dibina dalam kod Nilai elemen tatasusunan dari 1 hingga 30, mewakili tingkat bebas yang berbeza rancangan jualan. Perihalan kod adalah seperti berikut:
var highRiseBuilding [30]int
for i := 0; i < 30; i++ {
highRiseBuilding[i] = i + 1
}
// 区间
fmt.Println(highRiseBuilding[10:15])
// 中间到尾部的所有元素
fmt.Println(highRiseBuilding[20:])
// 开头到中间指定位置的所有元素
fmt.Println(highRiseBuilding[:2])
Barisan 14, menyewa bawah 2 tingkat, selalunya kedai komersial.
切片有点像C语言里的指针，指针可以做运算，但代价是内存操作越界，切片在指针的基础上增加了大小，约束了切片对应的内存区域，切片使用中无法对切片内部的地址和大小进行手动调整，因此切片比指针更安全、强大。
2) 表示原有的切片
生成切片的格式中，当开始和结束位置都被忽略时，生成的切片将表示和原切片一致的切片，并且生成的切片与原切片在数据内容上也是一致的，代码如下：
a := []int{1, 2, 3}
fmt.Println(a[:])a 是一个拥有 3 个元素的切片，将 a 切片使用 a[:] 进行操作后，得到的切片与 a 切片一致，代码输出如下：
[1 2 3]
3) 重置切片，清空拥有的元素
把切片的开始和结束位置都设为 0 时，生成的切片将变空，代码如下：
a := []int{1, 2, 3}
fmt.Println(a[0:0])代码输出如下：
除了可以从原有的数组或者切片中生成切片外，也可以声明一个新的切片，每一种类型都可以拥有其切片类型，表示多个相同类型元素的连续集合，因此切片类型也可以被声明，切片类型声明格式如下：
var name []Type
其中 name 表示切片的变量名，Type 表示切片对应的元素类型。
下面代码展示了切片声明的使用过程：
// 声明字符串切片
var strList []string
// 声明整型切片
var numList []int
// 声明一个空切片
var numListEmpty = []int{}
// 输出3个切片
fmt.Println(strList, numList, numListEmpty)
// 输出3个切片大小
fmt.Println(len(strList), len(numList), len(numListEmpty))
// 切片判定空的结果
fmt.Println(strList == nil)
fmt.Println(numList == nil)
fmt.Println(numListEmpty == nil)代码输出结果：
代码说明如下：
第 2 行，声明一个字符串切片，切片中拥有多个字符串。
第 5 行，声明一个整型切片，切片中拥有多个整型数值。
第 8 行，将 numListEmpty 声明为一个整型切片，本来会在{}中填充切片的初始化元素，这里没有填充，所以切片是空的，但是此时的 numListEmpty 已经被分配了内存，只是还没有元素。
第 11 行，切片均没有任何元素，3 个切片输出元素内容均为空。
第 14 行，没有对切片进行任何操作，strList 和 numList 没有指向任何数组或者其他切片。
第 17 行和第 18 行，声明但未使用的切片的默认值是 nil，strList 和 numList 也是 nil，所以和 nil 比较的结果是 true。
第 19 行，numListEmpty 已经被分配到了内存，但没有元素，因此和 nil 比较时是 false。
切片是动态结构，只能与 nil 判定相等，不能互相判定相等。声明新的切片后，可以使用 append() 函数向切片中添加元素。
如果需要动态地创建一个切片，可以使用 make() 内建函数，格式如下：
make( []Type, size, cap )
其中 Type 是指切片的元素类型，size 指的是为这个类型分配多少个元素，cap 为预分配的元素数量，这个值设定后不影响 size，只是能提前分配空间，降低多次分配空间造成的性能问题。
示例如下：
a := make([]int, 2) b := make([]int, 2, 10) fmt.Println(a, b) fmt.Println(len(a), len(b))
代码输出如下：
其中 a 和 b 均是预分配 2 个元素的切片，只是 b 的内部存储空间已经分配了 10 个，但实际使用了 2 个元素。
容量不会影响当前的元素个数，因此 a 和 b 取 len 都是 2。
温馨提示
使用 make() 函数生成的切片一定发生了内存分配操作，但给定开始与结束位置（包括切片复位）的切片只是将新的切片结构指向已经分配好的内存区域，设定开始与结束位置，不会发生内存分配操作。
切片的使用和数组是一模一样的：
func main() {
slice1 := []int{1,2,3,4}
fmt.Println(slice1[1])
}切片之所以称为切片，是因为它只是对应底层数组的一部分，看如下所示代码：
func main() {
slice := []int{10, 20, 30, 40, 50}
newSlice := slice[1:3]
}为了说明上面的代码，我们看下面的这张图：
第一个切片slice 能够看到底层数组全部5 个元素的容量，不过之后的newSlice 就看不到。对于newSlice，底层数组的容量只有4 个元素。newSlice 无法访问到它所指向的底层数组的第一个元素之前的部分。所以，对newSlice 来说，之前的那些元素就是不存在的。
需要记住的是，现在两个切片共享同一个底层数组。如果一个切片修改了该底层数组的共享部分，另一个切片也能感知到，运行下面的代码：
func main() {
slice := []int{10, 20, 30, 40, 50}
newSlice := slice[1:3]
slice[1] = 200
fmt.Println(newSlice[0])
}运行结果如下：
200
切片只能访问到其长度内的元素。试图访问超出其长度的元素将会导致语言运行时异常，比如对上面的newSlice，他只能访问索引为1和2的元素（不包括3），比如：
func main() {
slice := []int{10, 20, 30, 40, 50}
newSlice := slice[1:3]
fmt.Println(newSlice[3])
}运行代码，控制台会报错：
panic: runtime error: index out of range
goroutine 1 [running]:
main.main()
E:/go-source/go-arr/main.go:20 +0x11我们知道切片可以再生出切片，那么子切片的容量为多大呢？我们来测试一下：
func main() {
slice := make([]int, 2, 10)
slice1 := slice[1:2]
fmt.Println(cap(slice1))
}控制台打印结果为：
9 9
从结果我们可以推测，子切片的容量为底层数组的长度减去切片在底层数组的开始偏移量，比如在上面的例子中，slice1的偏移值为1，底层数组的大小为10，所以两者相减，得到结果9。
go提供了append方法用于向切片中追加元素，如下所示：
func main() {
slice := make([]int, 2, 10)
slice1 := slice[1:2]
slice2 := append(slice1, 1)
slice2[0] = 10001
fmt.Println(slice)
fmt.Println(cap(slice2))
}输出结果如下：
[0 10001] 9
此时slice，slice1，slice2共享底层数组，所以只要一个切片改变了某一个索引的值，会影响到所有的切片，还有一点值得注意，就是slice2的容量为9，记住这个值。
为了说明问题，我把例子改为如下所示代码：
func main() {
slice := make([]int, 2, 10)
slice1 := slice[1:2]
slice2 := append(slice1, 1)
slice2 = append(slice2, 1)
slice2 = append(slice2, 1)
slice2 = append(slice2, 1)
slice2 = append(slice2, 1)
slice2 = append(slice2, 1)
slice2 = append(slice2, 1)
slice2 = append(slice2, 1)
slice2 = append(slice2, 1)
slice2 = append(slice2, 1)
slice2 = append(slice2, 1)
slice2 = append(slice2, 1)
slice2[0] = 10001
fmt.Println(slice)
fmt.Println(slice1)
fmt.Println(cap(slice2))
}此时我们再次打印结果，神奇的事情出现了：
[0 0] [0] 18
虽然我们改变0位置的值，但是并没有影响到原来的slice和slice1，这是为啥呢？我们知道原始的slice2对应的底层数组的容量为9，经过我们一系列的append操作，原始的底层数组已经无法容纳更多的元素了，此时Go会分配另外一块内存，把原始切片从位置1开始的内存复制到新的内存地址中，也就是说现在的slice2切片对应的底层数组和slice切片对应的底层数组完全不是在同一个内存地址，所以当你此时更改slice2中的元素时，对slice已经来说，一点儿关系都没有。
另外根据上面的打印结果，你也应该猜到了，当切片容量不足的时候，Go会以原始切片容量的2倍建立新的切片，在我们的例子中2*9=18，就是这么粗暴。
在前面的例子中，我们创建子切片的时候，没有指定子切片的容量，所以子切片的容量和我们上面讨论的计算子切片的容量方法相等，那么我们如何手动指定子切片的容量呢？
在这里我们借用《Go实战》中的一个例子：
func main() {
source := []string{"Apple", "Orange", "Plum", "Banana", "Grape"}
slice := source[2:3:4]
fmt.Println(cap(slice))
}如果你仔细看的话，上面的子切片的生成方式和普通的切片有所不同，[]里面有三个部分组成，，第一个值表示新切片开始元素的索引位置，这个例子中是2。第二个值表示开始的索引位置（2）加上希望包括的元素的个数（1），2+1 的结果是3，所以第二个值就是3。为了设置容量，从索引位置2 开始，加上希望容量中包含的元素的个数（2），就得到了第三个值4。所以这个新的切片slice的长度为1，容量为2。还有一点大家一定要记住，你指定的容量不能比原先的容量，这里就是source的容量大，加入我们这样设置的话：
func main() {
source := []string{"Apple", "Orange", "Plum", "Banana", "Grape"}
slice := source[2:3:10]
fmt.Println(cap(slice))
}运行结果如下，报错了，哈哈：
panic: runtime error: slice bounds out of range [::10] with capacity 5
goroutine 1 [running]:
main.main()
E:/learn-go/slice/main.go:7 +0x1d关于如何迭代切片，我们可以使用range配置来使用，如下：
func main() {
slice:=[]int{1,2,4,6}
for _, value:=range slice{
fmt.Println(value)
}
}关于迭代切片，大家有一点需要注意，就以上面的例子为例，value只是slice中元素的副本，为啥呢？我们来验证这一点：
func main() {
slice:=[]int{1,2,4,6}
for index, value:=range slice{
fmt.Printf("value[%d],indexAddr:[%X],valueAddr:[%X],sliceAddr:[%X]\n",value,&index,&value,&slice[index])
}
}控制台打印结果如下：
value[1],indexAddr:[C00000A0B8],valueAddr:[C00000A0D0],sliceAddr:[C000010380] value[2],indexAddr:[C00000A0B8],valueAddr:[C00000A0D0],sliceAddr:[C000010388] value[4],indexAddr:[C00000A0B8],valueAddr:[C00000A0D0],sliceAddr:[C000010390] value[6],indexAddr:[C00000A0B8],valueAddr:[C00000A0D0],sliceAddr:[C000010398]
从上面的结果可以看到index和value的地址始终是不变的，所以它们始终是同一个变量，只是变量引用地址的内容发生了变化，从而验证迭代的时候，只能是切片元素的副本，最后看看sliceAddr代表的地址相隔8个字节，因为在64位系统上，每一个int类型的大小为8个字节。
函数间传递切片，也是以值的方式传递的，但是你还记得这篇博文开头给出的切片的布局么？
切片由三个部分组成，包括指向底层数组的指针，当前切片的长度，当前切片的容量，所以切片本身并不大，我们来测试一个切片的大小：
func main() {
slice:=[]int{1,2,4,6}
fmt.Println(unsafe.Sizeof(slice))
}测试结果为：
24
也就是这个slice切片的大小为24字节，所以当切片作为参数传递的时候，几乎没有性能开销，还有很重要的一点，参数生成的副本的地址指针和原始切片的地址指针是一样的，因此，如果你在函数里面修改了切片，那么会影响到原始的切片，我们来验证这点：
func main() {
slice:=[]int{1,2,4,6}
handleSlice(slice)
fmt.Println(slice)
}打印结果：
[100 2 4 6]
Atas ialah kandungan terperinci Bagaimana untuk mentafsir hirisan bahasa go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
Penggunaan kata kunci Jenis dalam Go
Cara melaksanakan senarai terpaut dalam go
Apakah perisian pengaturcaraan bahasa Go?
Bagaimana untuk belajar bahasa go dari 0 asas
Bagaimana untuk menentukan pembolehubah dalam golang
Apakah kaedah untuk melaksanakan lebihan beban operator dalam bahasa Go?
Apakah pengendali dalam bahasa Go?
Apakah kaedah penukaran data dalam golang?
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
