1. 核心數(shù)據(jù)結構

切片本身并不存儲數(shù)據(jù)，而是底層數(shù)組的一個“視圖”或描述符。其底層結構（reflect.SliceHeader）僅占用 3 個機器字長（64位系統(tǒng)為24字節(jié)）：

• Data（指針） ：指向底層數(shù)組中切片起點的真實內存地址。
• Len（長度） ：切片當前可訪問的有效元素個數(shù)。
• Cap（容量） ：底層數(shù)組從 Data 指針位置開始，到其物理空間末尾的總容量。

2. Len 與 Cap 的設計哲學

相比較于C語言的數(shù)組，為什么golang中還有l(wèi)en和cap的說法，既然底層已經占據(jù)了cap的內存，len不是多此一舉嗎？

分離 Len 與 Cap 的核心目的是兼顧性能與安全：

• Cap (性能緩沖) ：用于向操作系統(tǒng)“批發(fā)”內存。避免頻繁的 append 操作每次都觸發(fā)高昂的系統(tǒng)調用和內存分配（平攤開銷）。
• Len (語義與安全) ：劃定有效數(shù)據(jù)的邏輯邊界。攔截對已分配但未初始化（或已廢棄）內存區(qū)域的訪問，防止臟數(shù)據(jù)泄漏。

3. 切片表達式與底層坐標系

在表達式 arr[low : high : max] 中，三個參數(shù)均代表相對于原數(shù)組的物理索引，而非直接的長度或容量數(shù)值。

• 指針偏移：新切片的 Data 指針指向 arr[low]。low 之前的元素從新切片的視野中被永久剝離。
• 長度計算：Len = high - low
• 容量計算：Cap = max - low （max 絕對不能超過原底層數(shù)組的最大容量）

應用場景：完整切片表達式主要用于內存隔離，限制切片的 Cap，強制其在未來 append 時觸發(fā)擴容，從而避免意外覆蓋底層數(shù)組中的后續(xù)數(shù)據(jù)。

對于max的理解

max實際上是一個相對于原數(shù)組的索引，表示slice在原數(shù)組上的最大右邊界索引，而不是直接指定新切片的容量數(shù)字。

寫 arr[1:4:7] 時，底層其實是在說：“把索引 1 作為起點，索引 4 作為當前視口的終點，并且把索引 7 作為底層物理空間的絕對禁區(qū)（不能達到或越過索引 7）

var arr = [...]int{0, 1, 2, 3, 4, 5, 6}  
slice1 := arr[1:4:5] // 左閉右開區(qū)間，最大容量為 5
// slice1 => [1 2 3]  
fmt.Println(slice1)  
slice2 := arr[1:4:7]   
// high <= max <= cap 雖然 1 + 7 = 8 > 7=cap，但是這里不會報錯  
// slice2 => [1 2 3]  
fmt.Println(slice2)

4. 擴容機制 (Append)

切片長度增加時存在兩種截然不同的物理行為：

• 假擴容（在 Cap 范圍內） ：底層不分配任何新內存。切片僅僅是向后推移其右邊界（Len 增加），占用底層數(shù)組中預留的 Cap 空間，原地寫入新數(shù)據(jù)。
• 真擴容（超出 Cap） ：觸發(fā)內存重分配。Runtime 申請一塊全新、更大的連續(xù)內存，將舊底層數(shù)組的數(shù)據(jù)全量拷貝至新內存，追加新元素，最后將切片的 Data 指針修改為指向新內存（舊數(shù)組無引用后被 GC 收回）。

當真擴容發(fā)生時，slice追加的數(shù)組超出了原數(shù)組的cap，go內部創(chuàng)建一個新的數(shù)組，此時該slice的引用地址不再是arr

var arr = [...]int{1, 2, 3, 4}  
fmt.Println(arr) //[1 2 3 4]  
slice1 := arr[:]  
fmt.Println(slice1) //[1 2 3 4]  
slice1 = append(slice1, []int{5, 6, 7}...)  
fmt.Println(slice1) //[1 2 3 4 5 6 7]  
slice1 = append(slice1, 8)  
slice1[0] = 888  
fmt.Println(slice1) // [888 2 3 4 5 6 7 8]  
fmt.Println(arr)    // [1 2 3 4]

而假擴容時，則仍是在原數(shù)組上進行追加而已

var arr = [6]int{1,2,3,4}
fmt.Println(arr) //[1,2,3,4,0,0]
slice := arr[:4]
fmt.Println(slice) //[1,2,3,4]
slice = append(slice,5)
fmt.Println(arr) //[1,2,3,4,5,0]
fmt.Println(slice) //[1,2,3,4,5]

5. 參數(shù)傳遞機制：為何能修改原數(shù)組？

Go 語言所有參數(shù)傳遞均為嚴格的值傳遞（拷貝） 。

數(shù)組傳參：拷貝整個數(shù)組的全部元素（全量復?。?。在函數(shù)內修改副本，原數(shù)組毫無影響。

切片傳參：僅拷貝 SliceHeader（指針、Len、Cap 的拷貝）。

• 表現(xiàn)為“引用”的根本原因：復印件中的 Data 指針與原件指向同一塊底層數(shù)組內存。因此修改元素會穿透到原數(shù)組。
• 核心陷阱：在函數(shù)內對切片執(zhí)行 append，雖然可能修改底層數(shù)據(jù)，但無法改變外部切片的 Len 和 Cap（因為修改的是副本里的字段）。若觸發(fā)了“真擴容”，內部切片將指向新數(shù)組，與外部徹底脫軌。

簡單來說：- 因為切片是個引用類型,所以它作為參數(shù)傳遞給函數(shù),函數(shù)操作的實質是底層數(shù)組

func main() {
	var slice = make([]int,3,5) //len=3,cap=5
	fmt.Println(slice)  //[0,0,0]
	slice2:=slice[:5]  //slice實現(xiàn)了對slice的擴容,切片長度變?yōu)?
	fmt.Println(slice2) //[0,0,0,0,0]
	slice[0] = 999  //這里slice和slice的index=0位置都是999 因為他們引用的底層數(shù)組的index=0位置都是999
	fmt.Println(slice)
	fmt.Println(slice2)
	AddOne(slice) //[8888,0,0]
	fmt.Println(slice) //[8888,0,0]
	fmt.Println(slice2) //[8888,0,0,0]
}
func AddOne(s []int){
	s[0] = 8888
	fmt.Println(s)
}

6. 對于slice 的 slice

在 Go 語言中，每一次切片操作都會建立一個 “全新的相對坐標系” 。當你對一個 slice 再次進行切片時，所有的索引（low、high、max）都是基于當前這個 slice 的起點（索引 0） 來計算的，它根本不關心最底層的數(shù)組是從哪里開始的。

var arr = [...]int{0, 1, 2, 3, 4, 5, 6}  
slice1 := arr[1:4:5] // 左閉右開區(qū)間，最大容量為 5
// slice1 => [1 2 3]  
slice3 := slice1[1:3:4]
fmt.Println(slice3)  
// slice3 => [2 3]  這里的從slice[1]開始
slice4 := slice1[1:4]  
// slice4 => [2 3 4]  
fmt.Println(slice4)

到此這篇關于Golang中Slice 底層機制的實現(xiàn)的文章就介紹到這了,更多相關Golang Slice底層機制內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論