golang学习笔记17-切片
注：本人已有C，C++,Python基础，只写本人认为的重点。
一、切片的定义，与数组的区别
切片（slice）是go中非常重要的数据结构，它与数组（array）有一些关键的区别：
1.数组的大小是固定的，在定义时就必须指定，不能动态改变。而切片是动态的，可以根据需要扩展。
2.数组是值类型，传递数组时会复制整个数组。切片是引用类型，传递的是指向底层数组的指针，因此切片的操作会影响原始数据。
3.数组在声明时分配内存，其大小固定。切片在运行时可以根据需要动态分配内存，并且可以通过append函数增加元素，go会自动处理内存分配。
切片的本质是对数组一个连续片段的引用，这个片段可以是整个数组，或者是由起始和终止索引标识的一些项的子集。需要注意的是，终止索引标识的项不包括在切片内。切片提供了一个相关数组的动态窗口。切片的语法：var 切片名 []类型 = 数组的一个片段引用。示例如下：
package main
import "fmt"
func main() {
// 定义一个数组
arr := [5]int{10, 20, 30, 40, 50}
// 创建切片，引用数组的一个片段，注意区间是左闭右开
var slice []int = arr[1:4] // 包含索引 1 到 3 的元素，结果是 [20, 30, 40]
// 输出数组和切片
fmt.Println("数组:", arr) // 输出: 数组: [10 20 30 40 50]
fmt.Println("切片:", slice) // 输出: 切片: [20 30 40]
// 修改切片中的元素
slice[0] = 99
fmt.Println("修改后的数组:", arr) // 输出: 修改后的数组: [10 99 30 40 50]
fmt.Println("修改后的切片:", slice) // 输出: 修改后的切片: [99 30 40]
}
上述示例说明访问slice下标即访问数组元素，用指针的概念解释就是：slice是数组的头指针，用下标访问slice等效于取引用，即slice[i]=(*slice)[i]。所以slice可通过下标修改原数组，这就是为什么最后arr和slice都改变的原因。
二、容量与长度
切片有3个字段的数据结构：一个是指向底层数组的指针，一个是切片的长度，一个是切片的容量。长度是切片中实际存储的元素数，容量是切片能够存储的最大元素数，即从切片的起始位置到底层数组的末尾的元素数，它表示在不重新分配内存的情况下，切片可以扩展到的最大长度。切片slice的长度可通过len(slice) 获取，容量可通过cap(slice)获取。当用append函数向切片添加元素时，如果长度超过容量，go会自动分配新的底层数组，复制原有元素，容量也会相应增加。示例如下：
package main
import "fmt"
func main() {
slice := []int{1, 2, 3}
fmt.Println("长度:", len(slice)) // 输出: 长度: 3
fmt.Println("容量:", cap(slice)) // 输出: 容量: 3
slice = append(slice, 4, 5) // 添加元素
fmt.Println("新长度:", len(slice)) // 输出: 新长度: 5
fmt.Println("新容量:", cap(slice)) // 输出: 新容量: 6（可能会根据实现变化）
}
三、创建方式
package main
import "fmt"
func main() {
// 1. 定义一个切片，让它引用一个已创建的数组
arr := [5]int{10, 20, 30, 40, 50} // 创建一个数组
slice1 := arr[1:4] // 切片引用数组的一部分，包含索引 1 到 3 的元素
fmt.Println("切片1:", slice1) // 输出: 切片1: [20 30 40]
// 2. 使用 make 内置函数创建切片
slice2 := make([]int, 3) // 创建一个长度为 3 的切片，初始元素为 0
fmt.Println("切片2:", slice2) // 输出: 切片2: [0 0 0]
fmt.Println("切片2的容量:", cap(slice2)) // 输出: 切片2的容量: 3
// 可以指定容量
slice3 := make([]int, 2, 5) // 创建一个长度为 2，容量为 5 的切片
fmt.Println("切片3:", slice3) // 输出: 切片3: [0 0]
fmt.Println("切片3的容量:", cap(slice3)) // 输出: 切片3的容量: 5
// 3. 直接指定具体数组初始化切片
slice4 := []int{1, 2, 3, 4, 5} // 直接定义并初始化切片
fmt.Println("切片4:", slice4) // 输出: 切片4: [1 2 3 4 5]
}
四、遍历
package main
import "fmt"
func main() {
// 创建一个切片
slice := []int{10, 20, 30, 40, 50}
fmt.Println("常规 for 循环遍历:")
for i := 0; i < len(slice); i++ { // 使用索引遍历切片
fmt.Printf("索引 %d 的元素: %d\n", i, slice[i]) // 通过索引访问元素
}
fmt.Println("\nfor-range 遍历:")
for index, value := range slice { // range 返回索引和元素值
fmt.Printf("索引 %d 的元素: %d\n", index, value) // 直接使用元素值
}
}
五、一些细节
package main
import "fmt"
func main() {
arr := [5]int{1, 2, 3, 4, 5}
slice1 := arr[1:4]
// 【1】切片使用不能越界
fmt.Println("访问slice1的第一个元素:", slice1[0]) // 输出: 2
// fmt.Println(slice1[5])// 取消注释将导致运行时错误：索引越界（index out of range）
// 【2】切片引用数组的三种简写方式
// 1. 从头到某个索引
slice2 := arr[0:3] // 包含元素 1, 2, 3
fmt.Println("引用arr[0:3]:", slice2) // 输出: [1 2 3]
// 2. 从某个索引到末尾
slice3 := arr[1:] // 从索引 1 到末尾（包含元素 2, 3, 4, 5）
fmt.Println("引用arr[1:]:", slice3) // 输出: [2 3 4 5]
// 3. 从开始到末尾
slice4 := arr[:] // 包含所有元素
fmt.Println("引用arr[:]:", slice4) // 输出: [1 2 3 4 5]
// 【4】切片可以继续切片
slice5 := slice4[1:3] // 从 slice4 中切出元素 2 和 3
fmt.Println("从slice4切出的切片:", slice5) // 输出: [2 3]
// 【5】切片的拷贝
// 使用 copy 函数拷贝切片
slice6 := make([]int, len(slice4)) // 创建一个新的切片以存放拷贝
copy(slice6, slice4) // 拷贝 slice4 的内容到 slice6
fmt.Println("slice4的拷贝slice6:", slice6) // 输出: [1 2 3 4 5]
// 修改原切片，观察拷贝是否影响
slice4[0] = 100
fmt.Println("修改slice4后的slice6:", slice6) // 输出: [1 2 3 4 5]，拷贝不受影响
}