深入理解Go語言切片：共享內(nèi)存與append()陷阱

大家好！歡迎回到我的博客。?如果您在這里，您可能剛接觸Golang，或者您是經(jīng)驗豐富的開發(fā)者，想深入了解切片的內(nèi)部工作原理。那么，讓我們開始吧！

Go語言因其簡潔性和高效性而備受贊譽——正如人們常說的那樣，“Go語言就是能完成工作”。對于我們這些來自C、C 或Java等語言的開發(fā)者來說，Go語言簡潔明了的語法和易用性令人耳目一新。然而，即使在Go語言中，某些特性也可能讓開發(fā)者感到困惑，尤其是在處理切片和子切片時。讓我們揭開這些細微之處，更好地理解如何避免append()和切片共享內(nèi)存的常見陷阱。

Go語言中的切片是什么？

通常，當您需要一種數(shù)據(jù)結(jié)構(gòu)來存儲一系列值時，切片是Go語言中的首選。它們的靈活性來自于這樣一個事實：它們的長度不是其類型的一部分。此特性克服了數(shù)組的限制，使我們能夠創(chuàng)建一個可以處理任何大小切片的單個函數(shù)，并使切片能夠根據(jù)需要增長或擴展。

雖然切片與數(shù)組有一些相似之處，例如都是可索引的并且具有長度，但它們在數(shù)據(jù)管理方式上有所不同。切片充當對底層數(shù)組的引用，該數(shù)組實際上存儲切片的數(shù)據(jù)。從本質(zhì)上講，切片提供對該數(shù)組的某些或所有元素的視圖。因此，當您創(chuàng)建一個切片時，Go會自動處理創(chuàng)建保存切片元素/數(shù)據(jù)的底層數(shù)組。

切片的共享內(nèi)存

數(shù)組是連續(xù)的內(nèi)存塊，但使切片有趣的是它們?nèi)绾我么藘?nèi)存。讓我們分解切片的結(jié)構(gòu)：

type slice struct {
    array unsafe.Pointer // 指向底層數(shù)組的指針
    len   int           // 切片中的元素數(shù)量
    cap   int           // 底層數(shù)組的容量
}

當您創(chuàng)建一個切片時，它包含三個組件：

1. 指向底層數(shù)組的指針
2. len 切片的長度（它包含的元素數(shù)量）
3. cap 容量（在需要增長之前它可以包含的元素數(shù)量）

這就是事情變得有趣的地方。如果您有多個派生自同一數(shù)組的切片，則通過一個切片進行的更改將體現(xiàn)在其他切片中，因為它們共享相同的底層數(shù)組。

讓我們看下面的例子：

package main

import "fmt"

func main() {
    // 創(chuàng)建一個具有初始值的切片
    original := []int{1, 2, 3, 4, 5}

    // 創(chuàng)建一個子切片——兩個切片共享相同的底層數(shù)組！
    subslice := original[1:3]

    fmt.Println("未修改的子切片:", subslice)  // 輸出 => 未修改的子切片: [2 3]

    // 修改子切片
    subslice[0] = 42

    fmt.Println("原始切片:", original) // 輸出 => 原始切片: [1 42 3 4 5]
    fmt.Println("修改后的子切片:", subslice)  // 輸出 => 修改后的子切片: [42 3]
}

理解切片容量

在我們進一步深入之前，讓我們嘗試理解切片容量cap()。當您從現(xiàn)有的Go語言切片中獲取子切片時，新子切片的容量由原始切片從子切片開始位置的剩余容量決定。讓我們稍微分解一下：

當您從數(shù)組創(chuàng)建切片時，切片的長度是它最初包含的元素數(shù)量，而它的容量是它在需要增長之前可以包含的元素總數(shù)。

獲取子切片

當您從現(xiàn)有切片中獲取子切片時：

• 子切片的長度是您指定的元素數(shù)量。
• 容量計算為原始切片的容量減去子切片的起始索引。

讓我們看一個詳細的例子：

type slice struct {
    array unsafe.Pointer // 指向底層數(shù)組的指針
    len   int           // 切片中的元素數(shù)量
    cap   int           // 底層數(shù)組的容量
}

• 原始切片有 5 個元素，長度和容量均為 5。
• 當您使用 subslice := original[1:4] 時，它指向從索引 1 到 3 的元素 (2, 3, 4)。
• subslice 的長度是 4 - 1 = 3。
• subslice 的容量是 5 - 1 = 4，因為它從索引 1 開始，并包含到原始切片末尾的元素。

append()陷阱！

這就是開發(fā)者經(jīng)常被困住的地方。Go語言中的append()函數(shù)在處理子切片時可能會導致意外行為。

未使用的容量共享

子切片的容量包括不屬于其長度但位于原始切片容量范圍內(nèi)的元素。這意味著如果子切片增長，它可以訪問或修改這些元素。

讓我們考慮這個例子：

package main

import "fmt"

func main() {
    // 創(chuàng)建一個具有初始值的切片
    original := []int{1, 2, 3, 4, 5}

    // 創(chuàng)建一個子切片——兩個切片共享相同的底層數(shù)組！
    subslice := original[1:3]

    fmt.Println("未修改的子切片:", subslice)  // 輸出 => 未修改的子切片: [2 3]

    // 修改子切片
    subslice[0] = 42

    fmt.Println("原始切片:", original) // 輸出 => 原始切片: [1 42 3 4 5]
    fmt.Println("修改后的子切片:", subslice)  // 輸出 => 修改后的子切片: [42 3]
}

• subslice 最初指向 2, 3，容量為 4（它可以增長到原始切片的末尾）。
• 當您向subslice追加 60, 70 時，它使用原始切片的剩余容量。
• original和subslice都反映了這些更改，因為它們共享相同的底層數(shù)組。

驚訝嗎？append()操作修改了原始切片，因為底層數(shù)組中有足夠的容量。但是，如果我們超過容量或追加的元素超過容量允許的范圍，Go將為子切片分配一個新的數(shù)組，從而打破與原始切片的共享：

func main() {
    // 原始切片
    original := []int{1, 2, 3, 4, 5}

    // 創(chuàng)建一個子切片
    subslice := original[1:4] // 指向元素 2, 3, 4

    fmt.Println("子切片:", subslice)    // 輸出 => 子切片: [2 3 4]
    fmt.Println("子切片的長度:", len(subslice)) // 輸出 => 子切片的長度: 3
    fmt.Println("子切片的容量:", cap(subslice)) // 輸出 => 子切片的容量: 4
}

在這種情況下，append()創(chuàng)建了一個新的底層數(shù)組，因為原始容量已超過。

避免陷阱的最佳實踐

• 明確容量

func main() {
    original := []int{1, 2, 3, 4, 5}
    subslice := original[1:3] // 指向元素 2, 3

    fmt.Println("追加前原始切片:", original) // 輸出 => [1 2 3 4 5]
    fmt.Println("追加前子切片:", subslice)       // 輸出 => [2 3]
    fmt.Println("子切片的容量:", cap(subslice))    // 輸出 => 4

    // 在容量范圍內(nèi)追加到子切片
    subslice = append(subslice, 60, 70)

    // 追加到子切片后打印
    fmt.Println("追加后原始切片:", original)  // 輸出 => [1 2 3 60 70]
    fmt.Println("追加后子切片:", subslice)        // 輸出 => [2 3 60 70]
}

主要優(yōu)點是：

i. make([]int, len(subslice)) 創(chuàng)建一個具有其自身獨立底層數(shù)組的新切片。這至關重要——它不僅僅是一個新的切片頭，而是在內(nèi)存中一個全新的數(shù)組。

ii. copy() 然后只傳輸值，而不是內(nèi)存引用。這就像復印一份文件而不是共享原始文件。

• 使用完整的切片表達式

func main() {
    original := []int{1, 2, 3, 4, 5}
    subslice := original[1:3] // 指向元素 2, 3

    // 追加超出子切片容量的元素
    subslice = append(subslice, 60, 70, 80)

    fmt.Println("大容量追加后原始切片:", original) // 輸出 => [1 2 3 4 5]
    fmt.Println("大容量追加后子切片:", subslice)       // 輸出 => [2 3 60 70 80]
}

• 在將切片傳遞給不應修改原始數(shù)據(jù)的函數(shù)時，考慮不變性

// 假設我們從這里開始
original := []int{1, 2, 3, 4, 5}
subslice := original[1:3]  // subslice 指向 original 的底層數(shù)組

// 這是我們的解決方案：
newSlice := make([]int, len(subslice))  // 步驟 1：創(chuàng)建新的底層數(shù)組
copy(newSlice, subslice)               // 步驟 2：復制值

主要優(yōu)點是：

i. 數(shù)據(jù)保護：原始數(shù)據(jù)保持不變，防止意外副作用

ii. 可預測的行為：函數(shù)對輸入沒有隱藏的影響

iii. 并發(fā)安全：在處理過程中可以在其他 goroutine 中安全地使用原始數(shù)據(jù)

記住：

• 切片是對底層數(shù)組的引用
• 子切片與父切片共享內(nèi)存
• append() 是否創(chuàng)建新的底層數(shù)組取決于容量
• 當向具有可用容量的子切片追加元素時，它會修改父切片的數(shù)據(jù)。
• 當您想要避免共享時，請使用顯式內(nèi)存管理
• 當處理子切片時，請執(zhí)行以下任一操作：

type slice struct {
    array unsafe.Pointer // 指向底層數(shù)組的指針
    len   int           // 切片中的元素數(shù)量
    cap   int           // 底層數(shù)組的容量
}

祝您編碼愉快。記住，能力越大，責任越大，尤其是在共享內(nèi)存方面！?

恭喜您閱讀完本文。

您覺得這篇資源有幫助嗎？您有問題嗎？或者您發(fā)現(xiàn)了錯誤或錯別字？請在評論中留下您的反饋。

不要忘記與可能從中受益的其他人分享此資源。關注我以獲取更多信息。

以上是進行切片和子鏈條：了解共享內(nèi)存并避免```append''的詳細內(nèi)容。更多信息請關注PHP中文網(wǎng)其他相關文章！