Golang

关注公众号 jb51net

关闭
首页 > 脚本专栏 > Golang > Go切片

Go切片的具体使用

作者：hope_wisdom

本文主要介绍了Go切片的具体使用,包括声明切片、初始化切片、切片的切割、切片的添加、切片的删除、切片的复制、切片的遍历、多维切片等,感兴趣的可以了解一下

概述

在上一节的内容中，我们介绍了Go的数组，包括：声明数组、初始化数组、访问数组元素等。在本节中，我们将介绍Go的切片。在Go语言中，数组的长度是固定的，不能改变，这在某些场景下使用不太方便。切片（slice）是一种动态数组，它提供了更为灵活和便捷的方式来操作数组。切片是对数组的抽象，它包含了指向数组元素的指针、切片的长度和容量。

声明切片

切片的声明使用[]操作符，语法如下：

var sliceName []Type

其中，sliceName表示切片的名称，Type表示切片中元素的类型。与数组不同，声明切片时，不需要指定长度。

在下面的示例代码中，我们声明了一个名为numbers的整数类型切片，并初始为空切片。

var numbers []int

初始化切片

可以使用数组来初始化切片，语法如下：

var sliceName []Type = []Type{value1, value2, ..., valueN}

其中，Type表示切片中元素的类型，value1、value2、...、valueN是切片中元素的初始值。

在下面的示例代码中，我们创建了一个包含3个整数的切片，其初始值为1、2、3。还创建了一个包含2个字符串的切片，其初始值为“Hello”、“CSDN”。

package main

import "fmt"

func main() {
    var numbers []int = []int{1, 2, 3}
    text := []string{"Hello", "CSDN"}

    // 输出：[1 2 3]
    fmt.Println(numbers)
    // 输出：[Hello CSDN]
    fmt.Println(text)
}

我们还可以使用内置函数make()来初始化切片，传入类型、数量、容量（可忽略）即可，元素的初始值为类型的默认值。

package main

import "fmt"

func main() {
    var numbers []int = make([]int, 3)
    text := make([]string, 2)

    // 输出：[0 0 0]
    fmt.Println(numbers)
    // 输出：[ ]
    fmt.Println(text)
}

与数组相比，切片的长度是不固定的，可以追加元素。在追加时，可能使切片的容量增大。切片的长度可以由 len()函数获取，容量可以由cap()函数获取。

package main

import "fmt"

func main() {
    var numbers []int = make([]int, 3, 10)
    
    // 输出：3 10
    fmt.Println(len(numbers), cap(numbers))
}

如果切片声明后，没有初始化，则为空切片。空切片默认为nil，其长度和容量均为0。

package main

import "fmt"

func main() {
    var numbers []int
    
    // 输出：0 0
    fmt.Println(len(numbers), cap(numbers))
    if numbers == nil {
        // 输出：[]
        fmt.Println(numbers)
    }
}

切片的切割

在Go语言中，可以使用切片的切片操作来切割切片。切片的切片操作可以用来获取切片的一部分，或者将一个切片分割成多个子切片。切片的切片操作使用两个索引来指定切割的位置：第一个索引指定切割的起始位置，第二个索引指定切割的结束位置，但不包括该位置的元素。第一个索引不指定时，默认为0。第二个索引不指定时，默认为切片的长度。

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5, 6}
    // 输出：[3 4 5 6]
    fmt.Println(numbers[2:])
    // 输出：[1 2 3 4]
    fmt.Println(numbers[:4])
    // 输出：[3 4]
    fmt.Println(numbers[2:4])
    // 输出：[1 2 3 4 5 6]
    fmt.Println(numbers[:])
}

切片的添加

可以使用append()函数向切片添加一个或多个元素。append()函数会根据切片的容量和长度，自动调整底层数组的大小，并将新元素添加到切片的末尾。注意：append()函数会返回一个新的切片，包含添加元素后的结果；因此，需要将返回的结果重新赋值给原切片，以更新切片的内容。

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3}
    // 添加元素99和100到切片的末尾
    numbers = append(numbers, 99, 100)
    // 输出：[1 2 3 99 100]
    fmt.Println(numbers)
}

当向一个切片添加另一个切片的所有元素时，使用append()函数需要对第二个切片进行解包（切片后面添加符号...，用于展开切片中的元素），可参考下面的示例代码。

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3}
    numbers2 := []int{99, 100}
    // 添加另一个切片，需要解包
    numbers = append(numbers, numbers2...)
    // 输出：[1 2 3 99 100]
    fmt.Println(numbers)
}

切片的删除

切片的删除分为几种情况：从头部删除、从中间删除、从尾部删除。

删除开头的元素时，可以直接移动数据指针。假如有一个切片slice，则slice[1:]会删除开头1个元素，slice[N:]会删除开头N个元素。

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    // 删除开头2个元素
    numbers = numbers[2:]
    // 输出：[3 4 5]
    fmt.Println(numbers)
}

也可以不移动数据指针，但将后面的数据向开头移动，此时可用append()函数原地完成。

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    // 删除开头2个元素
    numbers = append(numbers[:0], numbers[2:]...)
    // 输出：[3 4 5]
    fmt.Println(numbers)
}

删除中间的元素时，需要对剩余元素进行一次整体移动，此时仍可用append()函数原地完成。

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5, 6}
    // 删除中间的3、4两个元素
    numbers = append(numbers[:2], numbers[4:]...)
    // 输出：[1 2 5 6]
    fmt.Println(numbers)
}

删除尾部的元素时，直接切割即可。

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5, 6}
    // 删除尾部的两个元素
    numbers = numbers[:len(numbers) - 2]
    // 输出：[1 2 3 4]
    fmt.Println(numbers)
}

切片的复制

可以使用copy()函数来复制切片，它接受两个参数：第一个参数是目标切片，第二个参数是源切片。copy()函数会将源切片中的元素复制到目标切片中，并返回实际复制的元素个数。注意：如果源切片和目标切片不一样大，则会按照其中较小的那个切片的元素个数进行复制。另外，切片的复制不是在末尾添加元素，而是从开头位置覆盖之前已经存在的元素。

package main

import "fmt"

func main() {
    slice1 := []int{1, 2, 3, 4, 5}
    slice2 := []int{66, 88, 99}

    // slice2的容量小，故只会复制slice1的前3个元素到slice2中
    copy(slice2, slice1)
    // 输出：[1 2 3]
    fmt.Println(slice2)

    slice2 = []int{66, 88, 99}
    copy(slice1, slice2)
    // 输出：[66 88 99 4 5]
    fmt.Println(slice1)
}

切片的遍历

有两种方法来实现切片的遍历：一是使用for循环，二是使用range关键字。

在下面的示例代码中，我们使用了一个for循环，从切片的索引0开始遍历到切片的长度减1。通过索引，我们可以访问切片中的每个元素，并打印出来。

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    for i := 0; i < len(numbers); i++ {
        fmt.Println(numbers[i])
    }
}

在下面的示例代码中，我们使用了range关键字来遍历切片。每次迭代时，range会返回当前元素的索引和值。我们可以使用它们来访问切片中的元素，这种方法更加简洁和易读。

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    for index, value := range numbers {
        fmt.Println(index, value)
    }
}

多维切片

多维切片是由一系列切片组成的，每个切片可以具有不同的长度和容量。要创建一个多维切片，首先需要创建一个初始切片。然后使用该切片来创建额外的切片，每个新切片都会将原始切片的元素拆分为更小的切片。

声明一个多维切片的语法格式如下：

var sliceName [][]...[]Type

其中，sliceName表示切片的名称，Type表示切片的类型，每个[]代表着一个维度，切片有几个维度就需要几个[]。

在下面的示例代码中，我们首先创建了一个初始切片slice，长度为3。然后，我们使用range循环为每个内部切片创建了长度为2的子切片。接下来，我们给多维切片中的元素进行了赋值。最后，我们使用嵌套的range循环打印了多维切片的内容。

package main
  
import "fmt"
  
func main() {
    // 创建一个初始切片，长度为3
    slice := make([][]int, 3)
    for i := range slice {
        // 每个内部切片长度为2
        slice[i] = make([]int, 2)
    }
  
    // 给多维切片中的元素赋值
    slice[0][0] = 50
    slice[0][1] = 60
    slice[1][0] = 70
    slice[1][1] = 80
    slice[2][0] = 90
    slice[2][1] = 100
  
    // 打印多维切片的内容
    for i := range slice {
        for j := range slice[i] {
            fmt.Println(slice[i][j])
        }
    }
}

到此这篇关于Go切片的具体使用的文章就介绍到这了,更多相关Go切片内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！ 

您可能感兴趣的文章:
阅读全文