Go切片教程展示了如何在Golang中使用切片。
数组是单一数据类型元素的集合。数组包含固定数量的元素，并且不能增长或收缩。数组的元素通过索引访问。
slice是对数组元素的动态大小、灵活的视图。切片可以在底层数组的范围内增长和收缩。Aslice不存储任何数据，它只是描述数组的一部分。
去声明切片
var s []T
我们声明了一个T类型的切片。切片的声明就像一个数组，只是我们没有在方括号[]中指定任何大小。
$ go version go version go1.18.1 linux/amd64
我们使用Go版本1.18。
去切片文字
可以使用切片文字创建切片。
package main
import "fmt"
func main() {
var s1 = []int{2, 5, 6, 7, 8}
s2 := []int{3, 5, 1, 2, 8}
fmt.Println("s1:", s1)
fmt.Println("s2:", s2)
}
在代码示例中，我们创建了两个切片。
var s1 = []int{2, 5, 6, 7, 8}
右边的表达式是一个切片字面量。
s2 := []int{3, 5, 1, 2, 8}
这里我们有一个速记等价物。
$ go run literal.go s1: [2 5 6 7 8] s2: [3 5 1 2 8]
Goslicemake函数
我们可以使用make内置函数在Go中创建新的切片。
func make([]T, len, cap) []T
make函数接受一个类型、一个长度和一个可选的容量。它分配一个大小等于给定容量的底层数组，并返回一个引用该数组的切片。
package main
import "fmt"
func main() {
vals := make([]int, 5)
fmt.Println("vals: ", vals)
vals[0] = 1
vals[1] = 2
vals[2] = 3
vals[3] = 4
vals[4] = 5
fmt.Println("vals: ", vals)
}
我们使用make函数创建一个大小为5的整数切片。最初，切片的元素全为零。然后我们为切片元素分配新值。
$ go run make_fun.go vals: [0 0 0 0 0] vals: [1 2 3 4 5]
Go切片长度和容量
len函数返回切片中的元素数。cap函数返回切片的容量。aslice的容量是底层数组中元素的数量，从切片中的第一个元素开始计数。
package main
import "fmt"
func main() {
vals := make([]int, 5, 10)
n := len(vals)
c := cap(vals)
fmt.Printf("The size is: %d\n", n)
fmt.Printf("The capacity is: %d\n", c)
vals2 := vals[0:4]
n2 := len(vals2)
c2 := cap(vals2)
fmt.Printf("The size is: %d\n", n2)
fmt.Printf("The capacity is: %d\n", c2)
}
在代码示例中，我们打印了两个切片的大小和容量。
$ go run len_cap.go The size is: 6 The capacity is: 6 The size is: 4 The capacity is: 6
去切片数组或切片
我们可以通过对现有数组或切片进行切片来创建切片。
为了形成切片，我们指定了一个下限和一个上限：a[low:high]。这将选择一个半开范围，其中包括第一个元素，但不包括最后一个元素。
我们可以省略上限或下限以使用它们的默认值。下限默认为零，上限默认为切片长度。
package main
import "fmt"
func main() {
vals := [...]int{1, 2, 3, 4, 5, 6, 7}
s1 := vals[1:4]
fmt.Printf("s1: %v, cap: %d\n", s1, cap(s1))
s2 := vals[5:7]
fmt.Printf("s2: %v, cap: %d\n", s2, cap(s2))
s3 := vals[:4]
fmt.Printf("s3: %v, cap: %d\n", s3, cap(s3))
s4 := vals[2:]
fmt.Printf("s4: %v, cap: %d\n", s4, cap(s4))
s5 := vals[:]
fmt.Printf("s5: %v, cap: %d\n", s5, cap(s5))
}
我们从整数数组创建切片。
vals := [...]int{1, 2, 3, 4, 5, 6, 7}
创建了一个整数数组。使用...运算符，Go会为我们计算数组的大小。
s2 := vals[5:7]
fmt.Printf("s2: %v, cap: %d\n", s2, cap(s2))
我们从vals数组创建一个切片。结果切片包含从索引5到索引7的元素；上限是非包容性的。
$ go run slicing.go s1: [2 3 4], cap: 6 s2: [6 7], cap: 2 s3: [1 2 3 4], cap: 7 s4: [3 4 5 6 7], cap: 5 s5: [1 2 3 4 5 6 7], cap: 7
Go切片迭代
使用for循环，我们可以在Go中迭代切片元素。
package main
import "fmt"
func main() {
words := []string{"falcon", "bold", "bear", "sky", "cloud", "ocean"}
for idx, word := range words {
fmt.Println(idx, word)
}
}
在代码示例中，我们使用for/range语句遍历一段单词。
$ go run iteration.go 0 falcon 1 bold 2 bear 3 sky 4 cloud 5 ocean
在下面的示例中，我们使用经典的for循环迭代切片。
package main
import "fmt"
func main() {
words := []string{"falcon", "bold", "bear", "sky", "cloud", "ocean"}
for i := 0; i < len(words); i++ {
fmt.Println(words[i])
}
}
我们使用for语句遍历一段单词。
$ go run iteration2.go falcon bold bear sky cloud ocean
去切片追加
内置的append函数将新元素附加到切片。
func append(s []T, vs ...T) []T
第一个参数是T类型的切片，其余参数是要附加到切片的T值。
append的结果值是一个切片，其中包含原始切片的所有元素加上提供的值。如果后备数组太小而无法容纳所有给定值，则会分配一个更大的数组。返回的切片将指向新分配的数组。
package main
import "fmt"
func main() {
vals := make([]int, 3)
fmt.Printf("slice: %v; len: %d; cap: %d \n", vals, len(vals), cap(vals))
fmt.Println("---------------------------")
vals = append(vals, 1)
vals = append(vals, 2)
vals = append(vals, 3)
vals = append(vals, 4, 5, 6)
fmt.Printf("slice: %v; len: %d; cap: %d \n", vals, len(vals), cap(vals))
}
在代码示例中，我们将新元素附加到一个已经有三个元素的切片。
vals := make([]int, 3)
首先，我们创建一个切片，其中三个元素初始化为0。
vals = append(vals, 1) vals = append(vals, 2) vals = append(vals, 3) vals = append(vals, 4, 5, 6)
我们将六个值附加到切片。onego中可以追加多个元素。
$ go run appending.go slice: [0 0 0]; len: 3; cap: 3 --------------------------- slice: [0 0 0 1 2 3 4 5 6]; len: 9; cap: 12
在幕后，Go扩大了底层数组以包含所有新元素。
package main
import (
"fmt"
"strings"
)
func main() {
words := []string{}
words = append(words, "an")
words = append(words, "old")
words = append(words, "falcon")
res := strings.Join(words, " ")
fmt.Println(res)
}
我们从一个空字符串切片开始。我们将三个词附加到切片中。然后我们使用strings.Join函数连接单词，同时在单词之间插入一个空格。
$ go run main.go an old falcon
去切片复制
内置的copy函数复制一个切片。
func copy(dst, src []T) int
该函数返回复制的元素数。
package main
import "fmt"
func main() {
vals := []int{1, 2, 3, 4, 5}
vals2 := make([]int, len(vals))
n := copy(vals2, vals)
fmt.Printf("%d elements copied\n", n)
fmt.Println("vals:", vals)
fmt.Println("vals2:", vals2)
}
在代码示例中，我们复制了一段整数。
$ go run copying.go 5 elements copied vals: [1 2 3 4 5] vals2: [1 2 3 4 5]
去切片删除元素
没有从切片中删除项目的内置函数。我们可以使用append函数进行删除。
package main
import (
"fmt"
)
func main() {
words := []string{"falcon", "bold", "bear", "sky", "cloud", "ocean"}
fmt.Println(words)
words = append(words[1:2], words[2:]...)
fmt.Println(words)
words = append(words[:2], words[4:]...)
fmt.Println(words)
}
在代码示例中，我们从切片中删除一个元素，然后删除两个元素。
words = append(words[1:2], words[2:]...)
这会从切片中移除第一个元素。我们通过附加两个切片并省略要删除的切片来完成删除。
$ go run remove_elements.go [falcon bold bear sky cloud ocean] [bold bear sky cloud ocean] [bold bear ocean]
去切片独特的元素
在下一个示例中，我们生成一个包含唯一元素的切片。
package main
import "fmt"
func uniq(vals []int) []int {
uvals := []int{}
seen := make(map[int]bool)
for _, val := range vals {
if _, in := seen[val]; !in {
seen[val] = true
uvals = append(uvals, val)
}
}
return uvals
}
func main() {
vals := []int{1, 2, 2, 3, 4, 4, 5, 6, 7, 8, 8, 8, 9, 9}
uvals := uniq(vals)
fmt.Printf("Original slice: %v\n", vals)
fmt.Printf("Unique slice: %v\n", uvals)
}
我们有一个包含重复元素的切片。我们创建了一个仅包含唯一元素的新切片。
seen := make(map[int]bool)
为了完成这项任务，我们创建了一个映射，为我们在切片中遇到的所有值存储一个布尔值true。
for _, val := range vals {
if _, in := seen[val]; !in {
seen[val] = true
uvals = append(uvals, val)
}
}
我们遍历切片中可能存在重复的元素。如果它不存在于seen映射中，我们将其存储在那里并将其附加到新的uvals切片。否则，我们将跳过if块。
$ go run uniq_elems.go Original slice: [1 2 2 3 4 4 5 6 7 8 8 8 9 9] Unique slice: [1 2 3 4 5 6 7 8 9]
去切片排序
Go包含用于对切片进行排序的sort包。
package main
import (
"fmt"
"sort"
)
func main() {
words := []string{"falcon", "bold", "bear", "sky", "cloud", "ocean"}
vals := []int{4, 2, 1, 5, 6, 8, 0, -3}
sort.Strings(words)
sort.Ints(vals)
fmt.Println(words)
fmt.Println(vals)
}
在代码示例中，我们对一片单词和整数进行排序。
$ go run sorting.go [bear bold cloud falcon ocean sky] [-3 0 1 2 4 5 6 8]
Go切片初值
切片的默认零值为nil。nil切片的长度和容量为0，并且没有底层数组。
当我们使用make函数创建切片时，所有元素都被初始化为0。
package main
import "fmt"
func main() {
var vals []int
if vals == nil {
fmt.Printf("slice is nil\n")
}
fmt.Printf("slice: %v; len: %d; cap: %d \n", vals, len(vals), cap(vals))
fmt.Println("---------------------------")
var vals2 = make([]int, 5)
fmt.Printf("slice: %v; len: %d; cap: %d \n", vals2, len(vals2), cap(vals2))
}
我们创建了两个具有默认零值和make-functioninitializedelements的切片。
$ go run initial.go slice is nil slice: []; len: 0; cap: 0 --------------------------- slice: [0 0 0 0 0]; len: 5; cap: 5
Goslice是引用类型
切片是Go中的引用类型。这意味着当我们将引用分配给新变量或将切片传递给函数时，将复制对切片的引用。
package main
import "fmt"
func main() {
vals := []int{ 1, 2, 3, 4, 5, 6 }
vals2 := vals
vals2[0] = 11
vals2[1] = 22
fmt.Println(vals)
fmt.Println(vals2)
}
在代码示例中，我们定义了一个切片并将切片分配给一个新变量。通过第二个变量所做的更改反映在原始切片中。
$ go run reftype.go [11 22 3 4 5 6] [11 22 3 4 5 6]
原始切片也被修改。
切片切片
Go切片还可以包含其他切片。
package main
import "fmt"
func main() {
words := [][]string{
{"sky", "ocean"},
{"red", "blue"},
{"C#", "Go"},
}
fmt.Printf("slice: %v; len: %d; cap: %d \n", words, len(words), cap(words))
}
该示例创建了一片切片。
$ go run sliceofslices.go slice: [[sky ocean] [red blue] [C# Go]]; len: 3; cap: 3
过滤结构切片
在下一个例子中，我们过滤了一段Go结构。
package main
import "fmt"
type User struct {
name string
occupation string
country string
}
func main() {
users := []User{
{"John Doe", "gardener", "USA"},
{"Roger Roe", "driver", "UK"},
{"Paul Smith", "programmer", "Canada"},
{"Lucia Mala", "teacher", "Slovakia"},
{"Patrick Connor", "shopkeeper", "USA"},
{"Tim Welson", "programmer", "Canada"},
{"Tomas Smutny", "programmer", "Slovakia"},
}
var programmers []User
for _, user := range users {
if isProgrammer(user) {
programmers = append(programmers, user)
}
}
fmt.Println("Programmers:")
for _, u := range programmers {
fmt.Println(u)
}
}
func isProgrammer(user User) bool {
return user.occupation == "programmer"
}
在代码示例中，我们定义了一部分用户。我们创建一个仅包含程序员的新切片。
type User struct {
name string
occupation string
country string
}
User结构具有三个字段。
users := []User{
{"John Doe", "gardener", "USA"},
{"Roger Roe", "driver", "UK"},
{"Paul Smith", "programmer", "Canada"},
{"Lucia Mala", "teacher", "Slovakia"},
{"Patrick Connor", "shopkeeper", "USA"},
{"Tim Welson", "programmer", "Canada"},
{"Tomas Smutny", "programmer", "Slovakia"},
}
这是User结构的原始切片。
var programmers []User
过滤后的用户/程序员存储在程序员切片中。
for _, user := range users {
if isProgrammer(user) {
programmers = append(programmers, user)
}
}
我们遍历users切片，仅当用户满足isProgrammer谓词时，才将当前用户添加到programmers切片。
func isProgrammer(user User) bool {
return user.occupation == "programmer"
}
对于occupation字段等于“程序员”的所有用户，IsProgrammer谓词返回true。
$ go run filter_slice_structs.go
Programmers:
{Paul Smith programmer Canada}
{Tim Welson programmer Canada}
{Tomas Smutny programmer Slovakia}
在本教程中，我们使用了Golang中的切片。
列出所有Go教程。
