09-引用型別-1-切片

行走的皮卡丘發表於2020-11-18

一 切片建立

切片(slice)解決了陣列長度不能擴充套件,以及基本型別陣列傳遞時產生副本的問題。

常用建立方式:

var s1 []int				// 和宣告陣列一樣,只是沒有長度,但是這樣做沒有意義,因為底層的陣列指標為nil
s2 := []byte {'a','b','c'}
fmt.Println(s1)				//輸出 []
fmt.Print(s2)				//輸出 [97 98 99]

使用make函式建立:

slice1 := make([]int,5)		// 建立長度為5,容量為5,初始值為0的切片
slice2 := make([]int,5,7)	// 建立長度為5,容量為7,初始值為0的切片
slice3 := []int{1,2,3,4,5}	// 建立長度為5,容量為5,並已經初始化的切片

從陣列建立:slice可以從一個陣列再次宣告。slice通過array[i:j]來獲取,其中i是陣列的開始位置,j是結束位置,但不包含array[j],它的長度是j-i:

// 宣告一個含有10個元素元素型別為byte的陣列
var arr = [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}

// 宣告兩個含有byte的slice
ar a, b []byte

// a指向陣列的第3個元素開始,併到第五個元素結束,現在a含有的元素: ar[2]、ar[3]和ar[4]
a = arr[2:5]		
// b是陣列arr的另一個slicre,b的元素是:ar[3]和ar[4]
b = arr[3:5]			

注意:宣告陣列時,方括號內寫明瞭陣列的長度或使用…自動計算長度,而宣告slice時,方括號內沒有任何字元。

從切片建立:

oldSlice := []int{1,2,3}
newSlice := oldSlice[:6]	//基於切片前6個元素建立,沒有的預設0

注意:如果選擇的舊切片長度超出了舊切片的cap()值(切片儲存長度),則不合法。

二 切片常見操作

2.1 切片常見內建函式

切片常用內建函式:

len()			返回切片長度
cap()			返回切片底層陣列容量
append()		對切片追加元素
func copy(dst, src []Type) int
				將src中資料拷貝到dst中,返回拷貝的元素個數

切片空間與元素個數:

slice1 := make([]int, 5, 10)
fmt.Println(len(slice1))			// 5
fmt.Println(cap(slice1))			// 10
fmt.Println(slice1)					// [0 0 0 0 0]

切片操作

//切片增加
slice1 = append(slice1,1,2)
fmt.Println(slice1)						//輸出[0 0 0 0 0 1 2]

//切片增加一個新切片
sliceTemp := make([]int,3)
slice1 = append(slice1,sliceTemp...)
fmt.Println(slice1)						//輸出[0 0 0 0 0 1 2 0 0 0]

//切片拷貝
s1 := []int{1,3,6,9}
s2 := make([]int, 10)	//必須給與充足的空間
num := copy(s2, s1)

fmt.Println(s1)			//[1 3 6 9]
fmt.Println(s2)			//[1 3 6 9 0 0 0 0 0 0]
fmt.Println(num)		//4

//切片中刪除元素
s1 := []int{1,3,6,9}
index := 2					//刪除該位置元素
s1 = append(s1[:index], s1[index+1:]...)
fmt.Println(s1)				//[1 3 9]

// 切片拷貝
s1 := []int{1,2,3,4,5}
s2 := []int{6,7,8}
copy(s1,s2) 				//複製s2前三個元素到slice1前3位置
copy(s2,s1)	 				//複製s1前三個元素到slice2

注意:沒有…會編譯錯誤,預設第二個引數後是元素值,傳入切片需要展開。如果追加的長度超過當前已分配的儲存空間,切片會自動分配更大的記憶體。

2.2 切片的一些簡便操作

  • slice的預設開始位置是0,ar[:n]等價於ar[0:n]
  • slice的第二個序列預設是陣列的長度,ar[n:]等價於ar[n:len(ar)]
  • 如果從一個陣列裡面直接獲取slice,可以這樣ar[:],因為預設第一個序列是0,第二個是陣列的長度,即等價於ar[0:len(ar)]
  • 切片的遍歷可以使用for迴圈,也可以使用range函式
// 宣告一個陣列
var array = [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
// 宣告兩個slice
var aSlice, bSlice []byte

// 演示一些簡便操作
aSlice = array[:3] // 等價於aSlice = array[0:3] aSlice包含元素: a,b,c
aSlice = array[5:] // 等價於aSlice = array[5:10] aSlice包含元素: f,g,h,i,j
aSlice = array[:] // 等價於aSlice = array[0:10] 這樣aSlice包含了全部的元素

// 從slice中獲取slice
aSlice = array[3:7] // aSlice包含元素: d,e,f,g,len=4,cap=7
bSlice = aSlice[1:3] // bSlice 包含aSlice[1], aSlice[2] 也就是含有: e,f
bSlice = aSlice[:3] // bSlice 包含 aSlice[0], aSlice[1], aSlice[2] 也就是含有: d,e,f
bSlice = aSlice[0:5] // 對slice的slice可以在cap範圍內擴充套件,此時bSlice包含:d,e,f,g,h
bSlice = aSlice[:] // bSlice包含所有aSlice的元素: d,e,f,g

2.3 切片的擷取

  • s[n]:切片s中索引為位置為n的項
  • s[:]:從切片s的索引位置0到len(s)-1所獲得的切片
  • s[low:]:從切片s的索引位置low到len(s)-1所獲得的切片
  • s[:high]:從切片s的索引位置0到high所獲得的切片
  • s[low:high]:從切片s的索引位置low到high所獲得的切片
  • s[low:high:max]:從low到high的切片,且容量cap=max-low

1.7 字串轉切片

str := "hello,世界"
a := []byte(str)		//字串轉換為[]byte型別切片
b := []rune(str)		//字串轉換為[]rune型別切片

三 切片儲存結構

與陣列相比,切片多了一個儲存能力值的概念,即元素個數與分配空間可以是兩個不同的值,其結構如下所示:

type slice struct {
	arrary = unsafe.Pointer		//指向底層陣列的指標
	len int						//切片元素數量
	cap int						//底層陣列的容量
}

所以切片通過內部的指標和相關屬性引用陣列片段,實現了變長方案,Slice並不是真正意義上的動態陣列。

合理設定儲存能力,可以大幅提升效能,比如知道最多元素個數為50,那麼提前設定為50,而不是先設為30,可以明顯減少重新分配記憶體的操作。

四 切片作為函式引數

func test(s []int) {
	fmt.Printf("test---%p\n", s) // 列印與main函式相同的地址
	s = append(s, 1, 2, 3, 4, 5)
	fmt.Printf("test---%p\n", s) // 一旦append的資料超過切片長度,則會列印新地址
	fmt.Println("test---", s)    // [0 0 0 1 2 3 4 5]
}

func main() {

	s1 := make([]int, 3)
	test(s1)
	fmt.Printf("main---%p\n", s1) // 不會因為test函式內的append而改變
	fmt.Println("main---", s1)    // [ 0 0 0]
}

相關文章