slice 切片数组测试记录【GO 基础】

〇、测试前准备

本文是在 GO 环境下测试记录系列之一，GO 基本环境部署步骤将略过，直接上代码。

下面是常用命令：【初始化 + 运行 + 编译】

// {GOPATH} 环境变量值， example 项目文件夹名称
{GOPATH}\src\example>
// 运行代码 // xxx.go 为文件全名
go run xxx.go
// 初始化 // 重复初始化提示：go: E:\Project\Go_WorkSpace\src\example\go.mod already exists
go mod init // 初始化成功时没有输出
go mod tidy // 添加缺少的或删除不需要的模块
// 编译，将源代码编译成可执行程序（.exe） // 可选项：-o xxx.exe 自定义应用程序名
go build [-o xxx.exe]

一、Slice 简介

slice 并不是数组或数组指针。它通过内部指针和相关属性引用数组片段，以实现变长方案。它有如下特点：

• 切片是数组的一个引用，因此切片是引用类型。但自身是结构体，值拷贝传递。
• 切片的容量（cap）可以改变，因此，切片可以视作是一个可变的数组。
• 切片遍历方式和数组一样，可以用 len() 求长度。表示可用元素数量，读写操作不能超过该限制。
• cap 可以求出 slice 最大扩张容量，不能超出数组限制。0 <= len(slice) <= len(array)，其中 array 是 slice 引用的数组。注意：
• 当通过 append 方法往 slice 中添加元素时超过了其容量时，会自动扩充，此时会大于 slice 的容量，就会重新分配底层数组，即便原数组并未填满，且与原 array 无关。
• 如果 slice == nil，那么 len、cap 结果都等于 0。

切片的定义：var 变量名 []类型，比如：var str []string、var arr []int。

二、测试记录

2.1 make 创建切片

语法：

var slice []type = make([]type, len)  // 全局变量
    slice  := make([]type, len)       // 局部变量
    slice  := make([]type, len, cap)

测试一下：

package main
import (
	"fmt"
)
func main() {
	s1 := make([]int, 2) // 等同于：make([]int, 2, 2)
	fmt.Printf("slice s1 : %v\n", s1)
	fmt.Printf("slice s1-len : %v\n", len(s1))
	fmt.Printf("slice s1-cap : %v\n", cap(s1))
	s2 := make([]int, 2, 4)
	fmt.Printf("slice s2 : %v\n", s2)
	s3 := make([]int, 3, 4)
	fmt.Printf("slice s3 : %v\n", s3)
	fmt.Printf("slice s3-len : %v\n", len(s3))
	fmt.Printf("slice s3-cap : %v\n", cap(s3))
}

2.2 append 追加数据 超出 cap

测试目的：通过 append 方法添加元素，超出 slice 的 cap 值。

package main
import (
	"fmt"
)
func main() {
	data := [...]int{0, 1, 2, 3, 4, 10: 0}
	s := data[:2:3]
	fmt.Println("data[:2:3]")
	fmt.Println(len(s))
	fmt.Println(cap(s))
	fmt.Println("append(s, 100, 200)")
	s = append(s, 100, 200) // 一次 append 两个值，超出 s.cap 限制
	fmt.Println(len(s))
	fmt.Println(cap(s))
	fmt.Println("append(s, 1000, 2000, 3000)")
	s = append(s, 1000, 2000, 3000) // 一次 append 两个值，超出 s.cap 限制
	fmt.Println(len(s))
	fmt.Println(cap(s))
	fmt.Println(&s[0], s)       // 重新分配底层数组，与原数组无关
	fmt.Println(&data[0], data) // 比对底层数组起始指针
}

详解：

1. data[:2:3]--截取数组 data 的 0~2 不包含 2，结果就是 [0,1]，len 长度是 2，cap 容量是 3。
2. append(s, 100, 200)--往切片 s 中添加两个值，此时结果测长度是 4，大于切片的容量 3，则会自动重新分配底层数组，将切片数组容量自动增加到 6（3*2），并将新值加入新的数组。
3. 通过对比两个数组起始指针，可发现它们是不同的数组了。

注意：切片数组的容量增加，是在原容量的基础上乘与 2，无论原容量是多少。

2.3 切片自定义截取

通过array[start : end : cap_value]开始和结束的整数值来指定截取范围，cap_value 标识容量。

• 若从 0 开始，则 start 可省。start 位包含。
• 若取到 array 最后，则 end 可省。end 位不包含。
• cap_value 指的是切片数组的容量截止位，为空则默认至原数组末尾。cap_value 位不包含。

package main
import (
	"fmt"
)
func main() {
	data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	ss := data[2:4] // 截取 2~4 位，且不包含 4
	fmt.Println(ss)
	fmt.Printf("slice len(ss) : %v\n", len(ss))
	fmt.Printf("slice cap(ss) : %v\n", cap(ss))
	s := data[2:4:7] // 截取 2~4 位，且不包含 4。容量截取到 7 位，且不包含 7
	fmt.Println(s)
	fmt.Printf("slice len(s) : %v\n", len(s))
	fmt.Printf("slice cap(s) : %v\n", cap(s))
	s[0] += 100
	p := &s[0] // 获取切片 s 中首个数据存储的地址
	*p += 10   // *int 获取底层数组元素的指针
	s[1] += 200
	fmt.Println(s)
	fmt.Println(data)
}

2.4 直接修改 struct array/slice 成员

如下代码，声明数组并定义其切片数组，然后分别对两者的一个数值位赋值：

package main
import (
	"fmt"
)
func main() {
	d := [5]struct {
		x int
	}{}
	s := d[:]
	d[1].x = 10
	s[2].x = 20
	fmt.Println(d)
	fmt.Println(s)
	fmt.Printf("%p, %p\n", &d, &d[0])
	fmt.Printf("%p, %p\n", &s, &s[0])
}

由上结果可知，数组和切片的实际值指的是同一个段内存中的数据，切片只是增加了对数组的一个引用。

2.5 切片拷贝 copy

函数 copy 在两个 slice 间复制数据，复制长度以 len 小的为准（换句话说就是，将重叠位的数据进行复制）。两个 slice 可指向同一底层数组，允许元素区间重叠。

应及时将所需数据 copy 到较小的 slice，以便释放超大号底层数组内存。

package main
import (
	"fmt"
)
func main() {
	data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	fmt.Println("array data : ", data)
	s1 := data[8:]
	s2 := data[:5]
	fmt.Printf("slice s1 : %v\n", s1)
	fmt.Printf("slice s2 : %v\n", s2)
	copy(s2, s1) // 短 -> 长
	fmt.Printf("copied slice s1 : %v\n", s1)
	fmt.Printf("copied slice s2 : %v\n", s2)
	fmt.Println("array data : ", data)
	fmt.Println("------------------------------------------")
	data2 := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	fmt.Println("array data2 : ", data2)
	s3 := data2[8:]
	s4 := data2[:5]
	fmt.Printf("slice s3 : %v\n", s3)
	fmt.Printf("slice s4 : %v\n", s4)
	copy(s3, s4) // 长 -> 短
	fmt.Printf("copied slice s3 : %v\n", s3)
	fmt.Printf("copied slice s4 : %v\n", s4)
	fmt.Println("array data2 : ", data2)
}

2.6 切片遍历

package main
import (
	"fmt"
)
func main() {
	data := [...]int{0, 1, 2}
	slice := data[:]
	for index, value := range slice {
		fmt.Printf("index : %v , value : %v\n", index, value)
	}
}

2.7 字符串切片

string 底层就是一个 byte 的数组，因此，也可以进行切片操作。

组成每个字符串的元素叫做“字符”，可以通过遍历或者单个获取字符串元素获得字符。 字符用单引号（’）包裹起来。

Go 语言中字符分两种：

• byte 型（或 uint8 类型），代表了 ASCII 码的一个字符，用于表示字母、数字、标点等英文状态的符号；
• rune 类型，代表一个 UTF-8 字符，实际上是一个 int32，用于表示除英文外其他国家语言文字、符号等字符。

因此 rune 类型可以是由一个或多个 byte 类型组成。

如下示例代码，将“世界”修改为“够浪”，其对应的 UTF-8 字符也随之改变。

package main
import (
	"fmt"
)
func main() {
	str := "你好，世界！GO!"
	fmt.Println(str)
	s := []rune(str)
	for index, value := range s {
		fmt.Printf("index: %v , value : %v\n", index, value)
	}
	s[3] = '够'
	s[4] = '浪'
	s = s[:]
	str = string(s)
	fmt.Println(str)
	for index, value := range s {
		fmt.Printf("index: %v , value : %v\n", index, value)
	}
}

参考：http://www.topgoer.com/http://www.topgoer.com/go%E5%9F%BA%E7%A1%80/%E5%88%87%E7%89%87Slice.html