เหตุใดฉันจึงไม่สามารถทำสำเนาชิ้นส่วนด้วย `copy ()` ได้?

ฉันต้องการทำสำเนาชิ้นส่วนใน Go และอ่านเอกสารมีฟังก์ชั่นการคัดลอกให้ฉันใช้

ฟังก์ชันคัดลอกในตัวจะคัดลอกองค์ประกอบจากชิ้นส่วนต้นทางไปยังชิ้นส่วนปลายทาง (ในกรณีพิเศษมันจะคัดลอกไบต์จากสตริงไปยังส่วนของไบต์ด้วย) ต้นทางและปลายทางอาจทับซ้อนกัน Copy ส่งคืนจำนวนองค์ประกอบที่คัดลอกซึ่งจะเป็นค่าต่ำสุดของ len (src) และ len (dst)

แต่เมื่อฉันทำ:

arr := []int{1, 2, 3}
tmp := []int{}
copy(tmp, arr)
fmt.Println(tmp)
fmt.Println(arr)

ของฉันtmpว่างเปล่าเหมือนเดิม (ฉันพยายามใช้ด้วยซ้ำarr, tmp):

[]
[1 2 3]

คุณสามารถตรวจสอบที่ไปสนามเด็กเล่น เหตุใดฉันจึงไม่สามารถคัดลอกชิ้นส่วนได้?

องค์ประกอบในตัวจะcopy(dst, src)คัดลอกmin(len(dst), len(src))องค์ประกอบ

ดังนั้นหากคุณdstว่างเปล่า ( len(dst) == 0) จะไม่มีการคัดลอก

ลองtmp := make([]int, len(arr))( Go Playground ):

arr := []int{1, 2, 3}
tmp := make([]int, len(arr))
copy(tmp, arr)
fmt.Println(tmp)
fmt.Println(arr)

เอาต์พุต (ตามคาด):

[1 2 3]
[1 2 3]

น่าเสียดายที่สิ่งนี้ไม่ได้รับการบันทึกไว้ในbuiltinแพ็คเกจ แต่มีการบันทึกไว้ในข้อกำหนดภาษา Go: การผนวกและคัดลอกส่วน :

จำนวนขององค์ประกอบที่คัดลอกขั้นต่ำของและlen(src)len(dst)

แก้ไข:

ในที่สุดเอกสารของcopy()ได้รับการอัปเดตและตอนนี้มีข้อเท็จจริงที่ว่าความยาวขั้นต่ำของต้นทางและปลายทางจะถูกคัดลอก:

Copy ส่งคืนจำนวนองค์ประกอบที่คัดลอกซึ่งจะเป็นค่าต่ำสุดของ len (src) และ len (dst)

อีกวิธีง่ายๆในการทำเช่นนี้คือการใช้appendซึ่งจะจัดสรรชิ้นส่วนในกระบวนการ

arr := []int{1, 2, 3}
tmp := append([]int(nil), arr...)  // Notice the ... splat
fmt.Println(tmp)
fmt.Println(arr)

เอาต์พุต (ตามคาด):

[1 2 3]
[1 2 3]

ดังนั้นชวเลขสำหรับการคัดลอกอาร์เรย์arrจะเป็นappend([]int(nil), arr...)

https://play.golang.org/p/sr_4ofs5GW

หากชิ้นส่วนของคุณมีขนาดเท่ากันก็จะใช้ได้ :

arr := []int{1, 2, 3}
tmp := []int{0, 0, 0}
i := copy(tmp, arr)
fmt.Println(i)
fmt.Println(tmp)
fmt.Println(arr)

จะให้:

3
[1 2 3]
[1 2 3]

จาก " Go Slices: usage and internalals ":

ฟังก์ชันคัดลอกรองรับการคัดลอกระหว่างชิ้นส่วนที่มีความยาวต่างกัน ( จะคัดลอกเฉพาะองค์ประกอบจำนวนน้อยกว่าเท่านั้น )

ตัวอย่างปกติคือ:

t := make([]byte, len(s), (cap(s)+1)*2)
copy(t, s)
s = t

สำเนา () รันด้วยความยาวน้อยที่สุดของ dst และ src ดังนั้นคุณต้องเริ่มต้น dst ตามความยาวที่ต้องการ

A := []int{1, 2, 3}
B := make([]int, 3)
copy(B, A)
C := make([]int, 2)
copy(C, A)
fmt.Println(A, B, C)

เอาท์พุท:

[1 2 3] [1 2 3] [1 2]

คุณสามารถเริ่มต้นและคัดลอกองค์ประกอบทั้งหมดในบรรทัดเดียวโดยใช้ append () ไปยังส่วนศูนย์

x := append([]T{}, []...)

ตัวอย่าง:

A := []int{1, 2, 3}
B := append([]int{}, A...)
C := append([]int{}, A[:2]...)
fmt.Println(A, B, C)    

เอาท์พุท:

[1 2 3] [1 2 3] [1 2]

เมื่อเทียบกับการจัดสรร + สำเนา () สำหรับองค์ประกอบมากกว่า 1,000 รายการให้ใช้ผนวก จริงๆแล้วการร้อง 1,000 ความแตกต่างอาจถูกละเลยให้เป็นไปตามกฎทั่วไปเว้นแต่คุณจะมีหลายชิ้น

BenchmarkCopy1-4                50000000            27.0 ns/op
BenchmarkCopy10-4               30000000            53.3 ns/op
BenchmarkCopy100-4              10000000           229 ns/op
BenchmarkCopy1000-4              1000000          1942 ns/op
BenchmarkCopy10000-4              100000         18009 ns/op
BenchmarkCopy100000-4              10000        220113 ns/op
BenchmarkCopy1000000-4              1000       2028157 ns/op
BenchmarkCopy10000000-4              100      15323924 ns/op
BenchmarkCopy100000000-4               1    1200488116 ns/op
BenchmarkAppend1-4              50000000            34.2 ns/op
BenchmarkAppend10-4             20000000            60.0 ns/op
BenchmarkAppend100-4             5000000           240 ns/op
BenchmarkAppend1000-4            1000000          1832 ns/op
BenchmarkAppend10000-4            100000         13378 ns/op
BenchmarkAppend100000-4            10000        142397 ns/op
BenchmarkAppend1000000-4            2000       1053891 ns/op
BenchmarkAppend10000000-4            200       9500541 ns/op
BenchmarkAppend100000000-4            20     176361861 ns/op

ข้อกำหนดภาษาโปรแกรม Go

ต่อท้ายและคัดลอกชิ้นส่วน

การคัดลอกฟังก์ชันจะคัดลอกองค์ประกอบส่วนจาก src ต้นทางไปยังปลายทาง dst และส่งคืนจำนวนองค์ประกอบที่คัดลอก อาร์กิวเมนต์ทั้งสองต้องมีองค์ประกอบที่เหมือนกันประเภท T และต้องกำหนดให้กับชิ้นส่วนประเภท [] T จำนวนองค์ประกอบที่คัดลอกคือ len (src) และ len (dst) ขั้นต่ำ ในกรณีพิเศษสำเนายังยอมรับอาร์กิวเมนต์ปลายทางที่กำหนดให้กับชนิด [] ไบต์ด้วยอาร์กิวเมนต์ต้นทางของประเภทสตริง แบบฟอร์มนี้คัดลอกไบต์จากสตริงลงในชิ้นส่วนไบต์

copy(dst, src []T) int
copy(dst []byte, src string) int

tmparrความต้องการที่ว่างพอสำหรับ ตัวอย่างเช่น,

package main

import "fmt"

func main() {
    arr := []int{1, 2, 3}
    tmp := make([]int, len(arr))
    copy(tmp, arr)
    fmt.Println(tmp)
    fmt.Println(arr)
}

เอาท์พุท:

[1 2 3]
[1 2 3]

หมายเหตุ:นี่เป็นวิธีแก้ปัญหาที่ไม่ถูกต้องตามที่ @benlemasurier พิสูจน์แล้ว

นี่คือวิธีการคัดลอกชิ้นส่วน ฉันช้าไปหน่อย แต่มีคำตอบที่ง่ายและเร็วกว่า @ Dave's นี่คือคำแนะนำที่สร้างขึ้นจากรหัสเช่น @ Dave's นี่คือคำแนะนำที่สร้างขึ้นโดยฉัน อย่างที่คุณเห็นมีคำแนะนำน้อยกว่ามาก มันคืออะไรappend(slice)ที่ทำสำเนาชิ้นส่วน รหัสนี้:

package main

import "fmt"

func main() {
    var foo = []int{1, 2, 3, 4, 5}
    fmt.Println("foo:", foo)
    var bar = append(foo)
    fmt.Println("bar:", bar)
    bar = append(bar, 6)
    fmt.Println("foo after:", foo)
    fmt.Println("bar after:", bar)
}

ผลลัพธ์นี้:

foo: [1 2 3 4 5]
bar: [1 2 3 4 5]
foo after: [1 2 3 4 5]
bar after: [1 2 3 4 5 6]