Go语言切片

提示

1. 创建和使用切片：切片（Slice）是 Go 中的一个灵活的数据结构，与数组类似，但没有固定大小。可以使用 [] 符号创建切片，并且可以在运行时动态添加或移除元素。
2. 切片与数组的区别：切片不需要在定义时指定其大小，这是它与数组的主要区别。切片可以从已有数组创建，或者使用 make() 函数直接创建。
3. 切片操作：切片支持多种操作，如访问元素、修改元素、追加元素（append()）、复制元素（copy()）和获取长度（len()）。切片还可以使用 for 或 for range 循环进行遍历。

切片是相同类型数据的集合，类似于数组。

然而，与数组不同的是，切片没有固定大小。我们可以向切片中添加或移除元素。

在 Golang 中创建切片

以下是在 Golang 中创建切片的方式：

numbers := []int{1, 2, 3, 4, 5}

这里，

• numbers - 切片的名称
• int - 表示切片只包含整数
• {1, 2, 3, 4, 5} - 切片的元素

你可能已经注意到我们留下了空的 [] 符号。这是因为我们可以向切片中添加元素，改变其大小。

注意：如果我们在 [] 符号内提供了大小，它就成了数组。例如，

// 这是一个数组
numbers := [5]int{1, 2, 3, 4, 5}

// 这是一个切片
numbers := []int{1, 2, 3, 4, 5}

Golang 切片示例

// 程序创建一个切片并打印其元素

package main
import "fmt"

func main() {

 // 声明一个整数类型的切片变量
 numbers := []int{1, 2, 3, 4, 5}

 // 打印切片
 fmt.Println("Numbers: ", numbers)
}

输出

Numbers: [1 2 3 4 5]

在上面的示例中，我们创建了一个名为 numbers 的切片。这里，int 指定了切片 numbers 只能存储整数。

注意：我们也可以使用 var 关键字来创建切片。例如，

var numbers = []int{1, 2, 3, 4}

在 Golang 中从数组创建切片

在 Go 编程中，我们也可以从现有数组创建切片。例如，

假设我们有一个数字数组

numbers := [8]int{10, 20, 30, 40, 50, 60, 70, 80}

现在，我们可以从这个数组中切割指定元素来创建一个新的切片。

sliceNumbers = numbers[4, 7]

这里，

• 4 是我们开始切割数组元素的起始索引
• 7 是我们想要获取数组元素的结束索引

在从数组创建切片时，起始索引是包含的，结束索引是排除的。因此，我们的切片将包含元素 [50, 60, 70]。

示例：在 Go 中从数组创建切片

// 程序从数组中创建一个切片

package main
import "fmt"

func main() {

 // 一个整数数组
 numbers := [8]int{10, 20, 30, 40, 50, 60, 70, 80}

 // 从数组中创建切片
 sliceNumbers := numbers[4 : 7]

 fmt.Println(sliceNumbers)

}

输出

[50, 60, 70]

切片函数

在 Go 中，切片提供了各种内置函数，允许我们对切片执行不同的操作。

函数	描述
append()	向切片添加元素
copy()	将一个切片的元素复制到另一个切片
Equal()	比较两个切片
len()	查找切片的长度

向切片中添加元素

我们使用 append() 函数向切片中添加元素。例如，

// 向切片中添加元素的程序

package main
import "fmt"

func main() {
 primeNumbers := []int{2, 3}

 // 向切片中添加元素 5, 7
 primeNumbers = append(primeNumbers, 5, 7)
 fmt.Println("质数:", primeNumbers)
}

输出

质数: [2 3 5 7]

这里，代码

primeNumbers = append(primeNumbers, 5, 7)

向 primeNumbers 添加了元素 5 和 7。

我们还可以使用 append() 函数将一个切片的所有元素添加到另一个切片中。例如，

// 将一个切片的元素添加到另一个切片的程序

package main
import "fmt"

func main() {

 // 创建两个切片
 evenNumbers := []int{2, 4}
 oddNumbers := []int{1, 3}

 // 将 oddNumbers 的元素添加到 evenNumbers 中
 evenNumbers = append(evenNumbers, oddNumbers...)
 fmt.Println("数字:", evenNumbers)
}

输出

数字: [2 4 1 3]

这里，我们使用了 append() 将 oddNumbers 的元素添加到 evenNumbers 元素列表中。

复制 Golang 切片

我们可以使用 copy() 函数将一个切片的元素复制到另一个切片中。例如，

// 将一个切片复制到另一个切片的程序

package main
import "fmt"

func main() {

 // 创建两个切片
 primeNumbers := []int{2, 3, 5, 7}
 numbers := []int{1, 2, 3}

 // 将 primeNumbers 的元素复制到 numbers 中
 copy(numbers, primeNumbers)

 // 打印 numbers
 fmt.Println("数字:", numbers)
}

输出

数字: [2 3 5]

在上述示例中，我们将 primeNumbers 的元素复制到了 numbers 中。

copy(numbers, primeNumbers)

这里，只有 primeNumbers 的前 3 个元素被复制到了 numbers 中。这是因为 numbers 的大小为 3，它只能容纳 3 个元素。

copy() 函数用目标数组的元素替换所有元素。

查找切片的长度

我们使用 len() 函数来查找切片内元素的数量。例如，

// 查找切片长度的程序

package main
import "fmt"

func main() {

 // 创建一个数字切片
 numbers := []int{1, 5, 8, 0, 3}

 // 查找切片的长度
 length := len(numbers)

 fmt.Println("长度:", numbers)

}

输出

长度: 5

在 Go 切片中循环

在 Go 中，我们可以使用 for 循环遍历切片。例如，

// 使用 for 循环遍历切片的程序

package main
import "fmt"

func main() {
 numbers := []int{2, 4, 6, 8, 10}

 // 循环遍历切片
 for i := 0; i < len(numbers); i++ {
 fmt.Println(numbers[i])
 }

}

输出

2
4
6
8
10

这里，len() 函数返回切片的大小。切片 numbers 的大小为 5，所以 for 循环迭代了 5 次。

常见问题

访问切片元素

在 Go 中，切片中的每个元素都与一个数字相关联。这个数字被称为切片索引。

我们可以使用索引号 （0, 1, 2 …） 访问切片元素。例如，

// 访问切片元素的程序

package main
import "fmt"

func main() {

 languages := []string{"Go", "Java", "C++

"}

 // 访问索引 0 处的元素
 fmt.Println(languages[0])

 // 访问索引 2 处的元素
 fmt.Println(languages[2])

 // 访问索引 0 到 2 的元素
 fmt.Println(languages[0:3])

}

输出

Go
C++
[Go Java C++]

在上述示例中，我们创建了一个名为 languages 的切片。

这里，我们可以看到每个切片元素都与一个索引号相关联。我们使用索引号来访问元素。

注意： 切片索引始终从 0 开始。因此，切片的第一个元素位于索引 0，而不是 1。

更改切片元素

我们可以使用相同的索引号来更改切片元素的值。例如，

package main
import "fmt"

func main() {
 weather := []string{"Rainy", "Sunny", "Cloudy"}

 // 更改索引 2 处的元素
 weather[2] = "Stromy"

 fmt.Println(weather)
}

输出

[Rainy Sunny Stromy]

这里，索引 2 处的值从 "Cloudy" 更改为 "Stromy"。

使用 make() 函数创建切片

在 Go 中，我们还可以使用 make() 函数创建切片。例如，

numbers := make([]int, 5, 7)

这里，我们创建了一个整数类型的切片。

• 5 是切片的长度（切片中的元素数量）
• 7 是切片的容量（切片可扩展的最大大小）

让我们看一个示例，

package main
import "fmt"

func main() {

 // 使用 make() 创建切片
 numbers := make([]int, 5, 7)

 // 向 numbers 添加元素
 numbers[0] = 13
 numbers[1] = 23
 numbers[2] = 33

 fmt.Println("数字:", numbers)
}

输出

数字: [13 23 33 0 0]

这里，我们创建了长度为 5 的切片。然而，我们只初始化了切片的 3 个值。

在这种情况下，剩余的值使用默认值 0 初始化。

使用 for range 循环遍历切片

除了使用 for 循环外，我们还可以在 Golang 中使用 for range 循环遍历切片。例如，

// 使用 for range 循环遍历切片的程序

package main
import "fmt"

func main() {
 numbers := []int{2, 4, 6, 8, 10}

 // for range 循环遍历切片
 for _, value := range numbers {
 fmt.Println(value)
 }

}

输出

2
4
6
8
10

这里，for range 循环从切片的第一个元素（2）遍历到最后一个元素（10）。要了解关于 range 的更多信息，请访问 Go range。