腳本之家服務器常用軟件

快捷導航

Go切片的具體使用

更新時間：2023年11月20日 11:41:00 作者：hope_wisdom

本文主要介紹了Go切片的具體使用,包括聲明切片、初始化切片、切片的切割、切片的添加、切片的刪除、切片的復制、切片的遍歷、多維切片等,感興趣的可以了解一下

概述

在上一節(jié)的內(nèi)容中，我們介紹了Go的數(shù)組，包括：聲明數(shù)組、初始化數(shù)組、訪問數(shù)組元素等。在本節(jié)中，我們將介紹Go的切片。在Go語言中，數(shù)組的長度是固定的，不能改變，這在某些場景下使用不太方便。切片（slice）是一種動態(tài)數(shù)組，它提供了更為靈活和便捷的方式來操作數(shù)組。切片是對數(shù)組的抽象，它包含了指向數(shù)組元素的指針、切片的長度和容量。

聲明切片

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

var sliceName []Type

其中，sliceName表示切片的名稱，Type表示切片中元素的類型。與數(shù)組不同，聲明切片時，不需要指定長度。

在下面的示例代碼中，我們聲明了一個名為numbers的整數(shù)類型切片，并初始為空切片。

var numbers []int

初始化切片

可以使用數(shù)組來初始化切片，語法如下：

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

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

在下面的示例代碼中，我們創(chuàng)建了一個包含3個整數(shù)的切片，其初始值為1、2、3。還創(chuàng)建了一個包含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)
}

我們還可以使用內(nèi)置函數(shù)make()來初始化切片，傳入類型、數(shù)量、容量（可忽略）即可，元素的初始值為類型的默認值。

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)
}

與數(shù)組相比，切片的長度是不固定的，可以追加元素。在追加時，可能使切片的容量增大。切片的長度可以由 len()函數(shù)獲取，容量可以由cap()函數(shù)獲取。

package main

import "fmt"

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

如果切片聲明后，沒有初始化，則為空切片?？涨衅J為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語言中，可以使用切片的切片操作來切割切片。切片的切片操作可以用來獲取切片的一部分，或者將一個切片分割成多個子切片。切片的切片操作使用兩個索引來指定切割的位置：第一個索引指定切割的起始位置，第二個索引指定切割的結(jié)束位置，但不包括該位置的元素。第一個索引不指定時，默認為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()函數(shù)向切片添加一個或多個元素。append()函數(shù)會根據(jù)切片的容量和長度，自動調(diào)整底層數(shù)組的大小，并將新元素添加到切片的末尾。注意：append()函數(shù)會返回一個新的切片，包含添加元素后的結(jié)果；因此，需要將返回的結(jié)果重新賦值給原切片，以更新切片的內(nèi)容。

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()函數(shù)需要對第二個切片進行解包（切片后面添加符號...，用于展開切片中的元素），可參考下面的示例代碼。

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)
}

切片的刪除

切片的刪除分為幾種情況：從頭部刪除、從中間刪除、從尾部刪除。

刪除開頭的元素時，可以直接移動數(shù)據(jù)指針。假如有一個切片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)
}

也可以不移動數(shù)據(jù)指針，但將后面的數(shù)據(jù)向開頭移動，此時可用append()函數(shù)原地完成。

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()函數(shù)原地完成。

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()函數(shù)來復制切片，它接受兩個參數(shù)：第一個參數(shù)是目標切片，第二個參數(shù)是源切片。copy()函數(shù)會將源切片中的元素復制到目標切片中，并返回實際復制的元素個數(shù)。注意：如果源切片和目標切片不一樣大，則會按照其中較小的那個切片的元素個數(shù)進行復制。另外，切片的復制不是在末尾添加元素，而是從開頭位置覆蓋之前已經(jīng)存在的元素。

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)
}

切片的遍歷

有兩種方法來實現(xiàn)切片的遍歷：一是使用for循環(huán)，二是使用range關鍵字。

在下面的示例代碼中，我們使用了一個for循環(huán)，從切片的索引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)
    }
}

多維切片

多維切片是由一系列切片組成的，每個切片可以具有不同的長度和容量。要創(chuàng)建一個多維切片，首先需要創(chuàng)建一個初始切片。然后使用該切片來創(chuàng)建額外的切片，每個新切片都會將原始切片的元素拆分為更小的切片。

聲明一個多維切片的語法格式如下：

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

其中，sliceName表示切片的名稱，Type表示切片的類型，每個[]代表著一個維度，切片有幾個維度就需要幾個[]。

在下面的示例代碼中，我們首先創(chuàng)建了一個初始切片slice，長度為3。然后，我們使用range循環(huán)為每個內(nèi)部切片創(chuàng)建了長度為2的子切片。接下來，我們給多維切片中的元素進行了賦值。最后，我們使用嵌套的range循環(huán)打印了多維切片的內(nèi)容。

package main
  
import "fmt"
  
func main() {
    // 創(chuàng)建一個初始切片，長度為3
    slice := make([][]int, 3)
    for i := range slice {
        // 每個內(nèi)部切片長度為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
  
    // 打印多維切片的內(nèi)容
    for i := range slice {
        for j := range slice[i] {
            fmt.Println(slice[i][j])
        }
    }
}

到此這篇關于Go切片的具體使用的文章就介紹到這了,更多相關Go切片內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: