陣列：
複製傳遞(不要按照c/c++的方式去理解，c/c++中陣列是引用傳遞)，定長

切片：
引用傳遞，底層實現是3個欄位 array(陣列) + len（長度） +cap（容量）

go/src/runtime/slice.go slice結構定義：
type slice struct {
	array unsafe.Pointer
	len  int
	cap  int
}

要特別注意的是，切片的引用傳遞指的是切片傳遞時，切片的array欄位是引用傳遞的，len和cap欄位依然是賦值傳遞。
寫個虛擬碼：

type Slice struct {
	Array []interface{}
	Len int
	Cap int
}

func fake() {
	slice1 := &Slice{
		Array: 指向一塊連續記憶體的定長陣列,Len: 0,Cap: 4
	}
	
	slice2 := slice1 // 這一行相當於如下：
	
	slice2 := &Slice{}
	slice2.Array = slice1.Array // 指向同一塊記憶體，所以說切片是引用傳遞
	slice2.Len = slice1.Len // len欄位被複制了
	slice2.Cap = slice2.Cap // cap欄位被複制了

    // 後續如果觸發了任一slice的array重新分配記憶體，另一個slice都是不知道的
	// 已經修改任一slice的len和cap，另一個slice也是不知道的
}

最後總結題

//
//輸出結果：
//array1: [1 2 3] array2 [100 2 3]
//slice1: [100 2 3] slice2 [100 2 3]
//
func TestSlice1(t *testing.T) {
	// 陣列是賦值傳遞
	array1 := [3]int{1,2,3}

	// 這裡array1複製了一份，array2和array1已經不是同一份資料了
	// 所以對陣列array1，array2的修改是互不影響的
	array2 := array1
	array2[0] = 100
	fmt.Println("array1:",array1,"array2",array2)



	// 切片是引用傳遞
	slice1 := make([]int,0)
	slice1 = append(slice1,1,3)

	// slice2和slice1引用的同一份資料，所以slice2對已有元素的修改，會影響到slice1
	// 這裡有個細節需要注意，往下面TestSlice2繼續看
	slice2 := slice1
	slice2[0] = 100
	fmt.Println("slice1:",slice1,"slice2",slice2)
}

/*
輸出結果
slice1: [1 2 3] slice2 [1 2 3 4]
slice1: [1 2 3] slice2 [1 2 3 4 5]
slice1: [1 2 3] slice2 [100 2 3 4 5]
 */
func TestSlice2(t *testing.T) {
	// 切片是引用傳遞
	slice1 := make([]int,4) // 容量是4
	slice1 = append(slice1,3)

	// slice2和slice1引用的同一份資料，所以slice2對元素的修改，會影響到slice1
	// 特別要注意的是，這裡說的引用同一份資料，實際上是指的slice1和slice2內部的ptr指向了同一個陣列
	// 但是slice1和slice2結構中的len和cap是複製傳遞的
	slice2 := slice1
	// 新增第4個元素，容量足夠，不會觸發內部ptr陣列重新分配
	slice2 = append(slice2,4)
	fmt.Println("slice1:",slice2)

	// 新增第5個元素，容量不足，slice2.ptr重新分配記憶體，此時slice2.ptr和slice1.ptr已經不是同一份記憶體了
	slice2 = append(slice2,5)
	fmt.Println("slice1:",slice2)

	// 所以這裡slice2對已有元素的修改，不會影響到slice1了
	slice2[0] = 100
	fmt.Println("slice1:",slice2)
}

到此這篇關於go特性之陣列與切片的問題的文章就介紹到這了,更多相關go陣列切片內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！