結論：
copy復制會比等號復制慢。但是copy復制為值復制，改變原切片的值不會影響新切片。而等號復制為指針復制，改變原切片或新切片都會對另一個產生影響。
測試復制速度：
func TestArr1(t *testing.T) {
var a []int
for i := 0; i 100000000; i++ {
a = append(a, i)
}
start := time.Now().UnixNano()
var b = make([]int, 1000000)
copy(b, a)
end := time.Now().UnixNano()
fmt.Println(end - start)
}
結果為 5001100
func TestArr2(t *testing.T) {
var a []int
for i := 0; i 100000000; i++ {
a = append(a, i)
}
start := time.Now().UnixNano()
var b = a[0:1000000]
end := time.Now().UnixNano()
fmt.Println(end - start)
_ = b
}
結果為0
結論：
等號復制要比copy賦值速度快
測試更改原切片是否影響新切片：
func TestArr1(t *testing.T) {
var a []int
for i := 0; i 100; i++ {
a = append(a, i)
}
var b = make([]int, 10)
copy(b, a)
a[0] = 999
fmt.Println(b[0])
}
結果0
func TestArr2(t *testing.T) {
var a []int
for i := 0; i 100; i++ {
a = append(a, i)
}
var b = a[0:10]
a[0] = 999
fmt.Println(b[0])
}
結果 999
結論：
copy為值復制，更改原切片不會影響新切片，而等號復制相反
補充：go語言，切片研究，容量，長度，復制，追加
今天學習了數組和切片，感覺數組不夠靈活，一旦創建，無法添加成員。但是切片就靈活多了，感覺切片存在兩種形態，第一種是映射數組來的，那么數組數據變化后，切片數據也變化，h j為映射切片 ,第二 種是獨立切片,切片獨立創建,并不依賴于任何數組, x y z均為獨立切片，z拷貝自y，當y數據改變時，z不受影響。
另外發現個有趣的事，就是切片容量 len，x剛創建時，容量是10，長度是10，增加一個成員后，容量變成20，長度變成11，說明append函數，在增加成員的時候，會大幅度增加容量，但是再看y，它采用循環增加成員的方式創建，創建完成后，長度是10，容量是16。
代碼：
var ar = [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
var h, j []byte
h = ar[2:5]
j = ar[0:8]
ar[2] = 'q'
fmt.Println(string(h))
fmt.Println(string(j))
fmt.Printf("j容量%s\n", cap(j))
fmt.Printf("j長度%s\n", len(j))
x := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
fmt.Println(x)
fmt.Printf("x容量%s\n", cap(x))
fmt.Printf("x長度%s\n", len(x))
x = append(x, 11)
fmt.Println(x)
fmt.Printf("x容量%s\n", cap(x))
fmt.Printf("x長度%s\n", len(x))
var y []int
for u := 0; u 10; u++ {
//y = append(y, fmt.Sprintf("%v", u))
y = append(y, u)
}
fmt.Println(y)
fmt.Printf("y容量%s\n", cap(y))
fmt.Printf("y長度%s\n", len(y))
y = append(y, 5)
fmt.Println(y)
var z = make([]int, len(y))
copy(z, y)
fmt.Println(z)
y[0] = 9
fmt.Println(y)
fmt.Println(z)
結果
qde
abqdefgh
j容量%!s(int=10)
j長度%!s(int=8)
[0 1 2 3 4 5 6 7 8 9]
x容量%!s(int=10)
x長度%!s(int=10)
[0 1 2 3 4 5 6 7 8 9 11]
x容量%!s(int=20)
x長度%!s(int=11)
[0 1 2 3 4 5 6 7 8 9]
y容量%!s(int=16)
y長度%!s(int=10)
[0 1 2 3 4 5 6 7 8 9 5]
[0 1 2 3 4 5 6 7 8 9 5]
[9 1 2 3 4 5 6 7 8 9 5]
[0 1 2 3 4 5 6 7 8 9 5]
后來我再給y加入個成員，他的容量還是16，為了弄清容量和長度的關系
我寫個循環看看
for u := 0; u 20; u++ {
//y = append(y, fmt.Sprintf("%v", u))
y = append(y, u)
fmt.Printf("y長度%s\n", len(y))
fmt.Printf("y容量%s\n", cap(y))
}
結果是
y長度%!s(int=1)
y容量%!s(int=2)
y長度%!s(int=2)
y容量%!s(int=2)
y長度%!s(int=3)
y容量%!s(int=4)
y長度%!s(int=4)
y容量%!s(int=4)
y長度%!s(int=5)
y容量%!s(int=8)
y長度%!s(int=6)
y容量%!s(int=8)
y長度%!s(int=7)
y容量%!s(int=8)
y長度%!s(int=8)
y容量%!s(int=8)
y長度%!s(int=9)
y容量%!s(int=16)
y長度%!s(int=10)
y容量%!s(int=16)
y長度%!s(int=11)
y容量%!s(int=16)
y長度%!s(int=12)
y容量%!s(int=16)
y長度%!s(int=13)
y容量%!s(int=16)
y長度%!s(int=14)
y容量%!s(int=16)
y長度%!s(int=15)
y容量%!s(int=16)
y長度%!s(int=16)
y容量%!s(int=16)
y長度%!s(int=17)
y容量%!s(int=32)
y長度%!s(int=18)
y容量%!s(int=32)
y長度%!s(int=19)
y容量%!s(int=32)
y長度%!s(int=20)
y容量%!s(int=32)
呵呵 ，這下明白了，添加成員時，容量是2的指數遞增的，2，4，8，16，32。
而且是在長度要超過容量時，才增加容量。
我想在以后的開發中，切片我一定會比數組用的多，因為在原來的項目里，幾乎所有數組都是無法提前知道它的長度的，都是會隨時增加成員的。
以上為個人經驗，希望能給大家一個參考，也希望大家多多支持腳本之家。如有錯誤或未考慮完全的地方，望不吝賜教。
您可能感興趣的文章:- go語言求任意類型切片的長度操作
- 如何在Go中使用切片容量和長度
- Go語言切片前或中間插入項與內置copy()函數詳解
- go語言中切片與內存復制 memcpy 的實現操作
- go語言中的二維切片賦值
- go語言中切片的長度和容量的區別
