Bilakah Fungsi append() Go Mencipta Slice Baharu?

Bilakah Go's Append() Mencipta Slice Baharu?

Fungsi append() bahasa Go digunakan untuk memanjangkan kepingan sedia ada. Menurut dokumentasi API terbina dalam, append() mungkin mencipta kepingan baharu dengan kapasiti yang lebih besar apabila kapasiti kepingan asal tidak mencukupi.

Walau bagaimanapun, tingkah laku ini menimbulkan persoalan apabila dipertimbangkan dalam konteks algoritma rekursif. Khususnya, algoritma berikut menjana gabungan abjad:

<code class="go">package main

import (
    "fmt"
)

func AddOption(c chan []bool, combo []bool, length int) {
    if length == 0 {
        fmt.Println(combo, "!")
        c <- combo
        return
    }
    var newCombo []bool
    for _, ch := range []bool{true, false} {
        newCombo = append(combo, ch)
        AddOption(c, newCombo, length-1)
    }
}

func main() {
    c := make(chan []bool)
    go func(c chan []bool) {
        defer close(c)
        AddOption(c, []bool{}, 4)
    }(c)
    for combination := range c {
        fmt.Println(combination)
    }
}</code>

Dalam kod ini, fungsi AddOption secara rekursif menambah ahli abjad pada hirisan, menghantar hasilnya melalui saluran. Walau bagaimanapun, pemerhatian menunjukkan bahawa hirisan yang dihantar ke saluran diubah suai selepas dihantar.

Percanggahan timbul kerana dokumentasi mencadangkan bahawa append() harus mengembalikan kepingan baharu, tetapi gelagat dalam kod tersebut menunjukkan sebaliknya. Artikel ini mengkaji mekanisme asas append() dan menjelaskan apabila ia mencipta hirisan baharu.

Memahami Perwakilan Slice

Untuk memahami gelagat append(), ia perlu penting untuk memahami perwakilan dalaman kepingan. Sepotong, walaupun penampilannya yang tersendiri, bukanlah struktur data serba lengkap. Sebaliknya, ia terdiri daripada deskriptor yang menunjuk kepada tatasusunan asas data sebenar.

Deskriptor hirisan terdiri daripada tiga komponen:

1. Panjang: Bilangan elemen pada masa ini dalam kepingan .
2. Kapasiti: Bilangan elemen yang boleh disimpan oleh tatasusunan pendasar.
3. Penunjuk Data: Penunjuk kepada elemen pertama tatasusunan pendasar.

Nilai Pulangan Append()

Apabila append() digunakan, fungsi ini mencipta deskriptor hirisan baharu dengan panjang, kapasiti dan penuding datanya sendiri. Ini selaras dengan dokumentasi, yang menyatakan bahawa append() "menempatkan semula [s] dan menyalin [ies] ke blok tatasusunan baharu."

Walau bagaimanapun, ini menimbulkan persoalan lain: mengapa perubahan dibuat pada kepingan deskriptor selepas ia dihantar ke saluran kekal dalam kepingan asal?

Memahami Rujukan Dikongsi

Kunci untuk menyelesaikan isu ini ialah memahami sifat penuding data dalam deskriptor hirisan. Penunjuk ini tidak mencipta salinan data asas; ia menunjuk kepada data yang sama seperti kepingan asal.

Oleh itu, apabila append() digunakan pada kepingan, walaupun ia mencipta deskriptor kepingan baharu, penuding data kekal sama. Ini bermakna bahawa apa-apa pengubahsuaian yang dibuat pada elemen sama ada deskriptor hirisan akan dicerminkan dalam kedua-dua kepingan, tidak kira di mana pengubahsuaian berlaku.

Demonstrasi

Untuk menggambarkan konsep ini , pertimbangkan coretan kod berikut:

<code class="go">package main

import "fmt"

func main() {
    s := make([]int, 0, 5)
    s = append(s, []int{1, 2, 3, 4}...)

    a := append(s, 5)
    fmt.Println(a)

    b := append(s, 6)
    fmt.Println(b)
    fmt.Println(a)
}</code>

Apabila kod ini dilaksanakan, ia mengeluarkan:

<code class="go">package main

import (
    "fmt"
)

func AddOption(c chan []bool, combo []bool, length int) {
    if length == 0 {
        fmt.Println(combo, "!")
        c <- combo
        return
    }
    var newCombo []bool
    for _, ch := range []bool{true, false} {
        newCombo = append(combo, ch)
        AddOption(c, newCombo, length-1)
    }
}

func main() {
    c := make(chan []bool)
    go func(c chan []bool) {
        defer close(c)
        AddOption(c, []bool{}, 4)
    }(c)
    for combination := range c {
        fmt.Println(combination)
    }
}</code>

Dalam contoh ini, kedua-dua kepingan a dan b pada mulanya berkongsi data asas yang sama. Walau bagaimanapun, apabila b diberikan nilai baharu, tatasusunan data asas baharu dibuat dan penuding data b dikemas kini untuk menunjuk kepadanya. Memandangkan masih merujuk penuding data yang sama, ia terus mengakses tatasusunan data lama.

Dengan mengubah suai kapasiti hirisan, ia boleh ditunjukkan bahawa kepingan memang berkongsi data asas apabila kapasiti mencukupi untuk mengelakkan pengagihan semula.

Kesimpulan

Fungsi append() Go memperuntukkan deskriptor kepingan baharu tetapi mengekalkan rujukan kepada tatasusunan data asal. Ini bermakna pengubahsuaian pada kepingan dalam algoritma rekursif akan kelihatan dalam semua kepingan yang berkongsi rujukan data yang sama. Memahami tingkah laku ini adalah penting untuk bekerja dengan kepingan secara berkesan dalam Go.

Atas ialah kandungan terperinci Bilakah Fungsi append() Go Mencipta Slice Baharu?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!