Go 语言-切片_go 定义切片

目录

前言

1、定义切片

2、切片的初始化

3、len() 和 cap() 函数

4、空 (nil) 切片

5、切片截取

6、append() 和 copy() 函数

---

前言

切片是对数组的抽象。

数组的长度是不可改变的，在特定的场景中这样的集合就不太合适，Go 中提供了一种灵活，功能强悍的内置类型切片("动态数组")，与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片二点容量增大。

1、定义切片

可以声明一个未指定大小的数组来定义切片。

var identifier []type

切片不需要说明长度。

或使用 make() 函数来创建切片。

var slice []type = make([]type, len)
或
slice := make([]type, len)

也可以指定容量，其中 capacity 为可选参数。

make([]T, length, capacity)  //这里的length是数组长度并且也是切片的初始长度

2、切片的初始化

定义格式：

s := []int{1, 2, 3}
//直接初始化切片，[] 表示切片类型，{1，2，3} 初始化值依次是1，2，3，其 cap=len=3。

s := arr[:]
//初始化切片 s ，是数组 arr 的引用。

s := arr[startIndex:endIndex]
//将 arr 中从下标 startIndex 到 endIndex-1 下的元素创建为一个新的切片。

s := arr[startIndex:]
//默认从下标开始的startIndex元素到最后一个元素

s := arr[:endIndex]
//默认 endIndex 时将表示一直到 arr 的最后一个元素。

var := make([]int, len, cap)
//通过内置函数 make() 初始化切片 s，[]int 标识为其元素类型为 int 的切片。

示例：

package main
 
import "fmt"
 
func main() {
 
	//定义切片，切片的长度是不固定的。
	selice := []int{1, 2, 3, 4, 5}
	//定义数组
	arr := []int{10, 20, 30, 40, 50}
	//来自数组 arr 的切片
	selice1 := arr[:]
	//[start:end] start：起始下标，end：结束下标(前一位)
	//从下标为1开始取到最后一个元素
	selice2 := arr[1:]
	selice3 := arr[:4]
 
	fmt.Printf("selice的切片类型为：%T\n", selice)
	fmt.Println("selice", selice)
	fmt.Printf("selice1的类型：%T\n", selice1)
	fmt.Println("selice1", selice1)
	fmt.Println("selice2", selice2)
	fmt.Println("selice3", selice3)
 
}
 
//运行结果为：
selice的切片类型为：[]int
selice [1 2 3 4 5]
selice1的类型：[]int
selice1 [10 20 30 40 50]
selice2 [20 30 40 50]
selice3 [10 20 30 40]
 

3、len() 和 cap() 函数

切片是可以索引的，并且可以由 len() 方式获取长度。

切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。

示例：

package main
 
import "fmt"
 
func main() {
 
	selice := make([]int, 3, 6)
	printInfo(selice)
}
func printInfo(s []int) {
	fmt.Printf("切片的长度：%d,切片的容量%d,切片的结构：%v\n", len(s), cap(s), s)
}
 
//运行结果为：
切片的长度：3,切片的容量6,切片的结构：[0 0 0]

4、空 (nil) 切片

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

示例：

package main
 
import "fmt"
 
func main() {
 
	var selice []int
	if selice == nil {
		fmt.Println("定义的selice是：空切片")
	}
	printInfo(selice)
}
func printInfo(s []int) {
	fmt.Printf("切片的长度:%d 切片的容量:%d 切片的结构:%v", len(s), cap(s), s)
}
 
//运行结果为：
定义的selice是：空切片
切片的长度:0 切片的容量:0 切片的结构:[]

5、切片截取

可以通过以下方式来截取切片。

示例：

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]

6、append() 和 copy() 函数

如果想增加切片的容量，必须创建一个新的更大的切片并把原切片的内容都拷贝过来。

示例：从拷贝切片的 copy 方法和向切片追加新元素的 append 方法。

package main
 
import "fmt"
 
func main() {
 
	//原始切片
	var numbers []int
	fmt.Println(numbers)
 
	//追加元素
	numbers = append(numbers, 1, 3, 5, 7)
	fmt.Println(numbers)
	printSlice(numbers)
 
	//创建一个更大容量的切片
	numbers1 := make([]int, len(numbers), (cap(numbers))*2)
	//切片复制，新切片在前，原始切片在后
	copy(numbers1, numbers)
	printSlice(numbers1)
}
func printSlice(x []int) {
	fmt.Printf("len=%d  cap=%d slice=%v\n", len(x), cap(x), x)
}
 
//运行结果为：
[]
[1 3 5 7]
len=4  cap=4 slice=[1 3 5 7]
len=4  cap=8 slice=[1 3 5 7]