Go 語言中的動態陣列:深入解析切片

閱讀時間約 9 分鐘


raw-image

👨‍💻簡介

在 Go 語言中,切片(Slice)是一種動態序列的資料結構,能夠方便地存儲和操作多個相同類型的元素。切片相比於陣列,更具有彈性,因為它的大小是可變的,可以根據需要動態增長或縮小。切片在處理集合型資料時非常實用,讓你能夠輕鬆地新增、刪除、修改和操作元素,同時避免了固定大小的限制。

切片的基本概念

切片是由一個指向陣列的指針、切片長度和切片容量組成的。切片的長度指的是切片中實際包含的元素個數,而切片的容量則是從切片開始的底層陣列中能夠訪問的元素個數。切片的容量可以大於或等於切片的長度。

宣告和初始化切片

在 Go 中,宣告和初始化切片可以使用以下的語法:

var slice1 []int                     // 創建一個整數切片,大小和容量都是 0
slice2 := []string{"A", "B", "C"} // 創建一個包含三個字串元素的切片
slice3 := make([]int, 5) // 創建一個整數切片,大小為 5,容量也為 5
slice4 := make([]int, 3, 5) // 創建一個整數切片,大小為 3,容量為 5

切片的基本操作

新增元素到切片

Go語言中有個內件函式append(),可以用來新增元素到切片中,這使得切片能夠根據需求動態增長。

numbers := []int{10, 20, 30}
numbers = append(numbers, 40, 50) // 新增兩個元素到切片

需要注意的是,如果切片的容量不足以容納新增的元素,append() 函式會創建一個新的切片,並將舊的元素和新的元素一同複製到新的切片中。

查詢和修改切片元素

切片的元素可以通過索引來存取,索引從 0 開始計數。

numbers := []int{10, 20, 30, 40, 50}
firstNumber := numbers[0] // 存取第一個元素,值為 10
secondNumber := numbers[1] // 存取第二個元素,值為 20
numbers[2] = 35 // 修改切片中的元素,將第三個元素改為 35

切割和遍歷切片

可以使用切片的切割操作來獲取部分切片,這可以通過指定切片的起始索引和結束索引來實現:

numbers := []int{10, 20, 30, 40, 50}
subSlice := numbers[1:4] // 從第二個元素到第四個元素的子切片,值為 [20 30 40]
  • [:]:使用 [:] 語法可以獲得完整的切片,即包含所有元素的切片。
  • [x:]:這種語法表示從索引 x 開始,提取所有直到切片結尾的元素。
  • [:x]:這種語法表示提取從開頭到索引 x-1 的元素,不包含索引 x 的元素。

切片的遍歷可以使用傳統的索引方式,或者使用 range 來簡化遍歷過程。

numbers := []int{10, 20, 30, 40, 50}

// 使用傳統的索引方式遍歷切片
for i := 0; i < len(numbers); i++ {
fmt.Println(numbers[i])
}
// 使用 range 遍歷切片
for index, value := range numbers {
fmt.Printf("索引:%d,值:%d\n", index, value)
}
for i := range numbers {
fmt.Println(numbers[i])
}

刪除切片元素

雖然切片沒有內建的刪除方法,不過可以使用切片的切割操作,將不需要的元素排除在外。

slice := []int{10, 20, 30, 40, 50}
indexToDelete := 2
slice = append(slice[:indexToDelete], slice[indexToDelete+1:]...) // 刪除索引 2 的元素

切片的容量

切片的容量就是指,你從切片開始的位置能夠往後訪問到的元素數量。當你在切片上進行新增元素的操作時,如果新加進來的元素數量超過了切片目前的容量,Go 語言會做一些事情:它會重新搞一個更大的陣列,然後把舊的元素都複製到這個新陣列中。這個過程會花一些時間,也就是所謂的性能開銷。

package main

import "fmt"
func main() {
numbers := []int{1, 2, 3}
fmt.Println("長度:", len(numbers)) // 輸出:長度:3
fmt.Println("容量:", cap(numbers)) // 輸出:容量:3
slice := numbers[1:2]
fmt.Println("切片:", slice) // 輸出:切片:[2]
fmt.Println("切片長度:", len(slice)) // 輸出:切片長度:1
fmt.Println("切片容量:", cap(slice)) // 輸出:切片容量:2
// 切片的容量是從切片的起始索引開始計算,一直到底層陣列的末尾索引。因此容量為2
// 新增元素超過切片容量時,會自動擴容並分配更大的底層陣列
slice = append(numbers, 4) // 新切片為 [1, 2, 3, 4]
fmt.Println("切片:", slice) // 輸出:切片:[1 2 3 4]
fmt.Println("切片長度:", len(slice)) // 輸出:切片長度:4
fmt.Println("切片容量:", cap(slice)) // 輸出:切片容量:6
}

切片的特性、限制與使用場景

切片的特性

  • 切片的大小是動態的,可以隨時進行增長或縮小。
  • 切片可以方便地從現有的陣列或切片中創建,不需要顯式地指定容量。
  • 切片的新增、刪除、修改操作都非常方便,讓你能夠輕鬆地操作集合型資料。
  • 切片的背後通常使用動態陣列來實現,因此在內存佈局上更具彈性,不受固定大小的限制。
  • 切片是引用類型,這意味著它們引用底層的陣列,而不是複製數據。當你將一個切片賦值給另一個切片,它們實際上共享同一份數據。因此,對其中一個切片所做的修改將影響到另一個切片。 以下是一個實際案例:
slice1 := []int{1, 2, 3}
slice2 := slice1
slice2[0] = 3
fmt.Println(slice1, slice2) // 輸出:[3 2 3] [3 2 3]

在這裡,修改 slice2 的值同樣影響了 slice1,因為它們引用同一份底層數據。這是切片和陣列之間的一個重要區別。

切片的限制

  • 記憶體配置: 切片的內部實現中使用了底層的陣列,因此切片所佔用的記憶體空間可能比實際所需大。當切片的元素數量增加時,Go 語言可能會重新配置更大的陣列,導致一些性能開銷。
  • 不適用於大型資料: 對於大型資料集合,切片可能不是最佳選擇。大型切片可能導致記憶體占用過多,影響程式的效能。
  • 不支援多維切片: 切片僅支援一維結構,如果需要處理多維資料,可能需要自行實現多維切片的概念。

使用場景

  • 動態資料集合: 切片的大小是可變的,使其非常適用於處理動態資料集合,無需事先知道集合的大小。
  • API 請求和回應: 在處理 API 請求和回應時,切片可用於儲存和解析不確定數量的請求參數或回應資料。
  • 資料過濾和轉換: 使用 range 遍歷切片,可以輕鬆地過濾或轉換切片中的元素,進行處理和計算。
  • 傳遞函式參數: 切片的引用類型特性使其適用於傳遞函式參數,避免不必要的資料複製。
  • 檔案讀寫: 切片可用於讀取大量數據,進行處理後再寫回檔案。
  • 實現堆疊和佇列: 使用切片可以實現簡單的堆疊(後進先出)和佇列(先進先出)結構。
  • 排序和搜尋: 切片在排序和搜尋資料時非常有用,可以利用 sort 套件進行排序,並使用二分搜尋等技術進行搜尋。

常見用法

  • 資料過濾和轉換
// 將切片中的所有元素乘以 2
numbers := []int{1, 2, 3, 4, 5}
for i := range numbers {
numbers[i] *= 2
}

// 過濾出大於 3 的元素
filteredNumbers := []int{}
for _, num := range numbers {
if num > 3 {
filteredNumbers = append(filteredNumbers, num)
}
}
  • 傳遞函式參數
func modifySlice(slice []int) {
slice[0] = 100
}

numbers := []int{1, 2, 3}
modifySlice(numbers)

小結

切片是 Go 語言中非常實用的資料結構,它解決了陣列大小固定的限制,讓你能夠輕鬆地處理動態大小的集合型資料。切片的操作包括取得、修改、新增、刪除等,讓你可以靈活地處理資料集合。

在遍歷切片時,range 很方便地提供了索引和值,讓你能夠輕鬆地訪問切片中的元素。切片的特性和優勢使得它在處理動態數據集合時成為 Go 程式設計中的一個重要工具。

📚Reference

17會員
78內容數
golang
留言0
查看全部
發表第一個留言支持創作者!