Mengapa Menghiris Semula Go Slice Tidak Sentiasa Mengurangkan Kapasitinya?

Menghiris Semula Kepingan di Golang

Dalam Go, kepingan menyediakan cara yang fleksibel untuk mengurus koleksi elemen. Walaupun membuat dan mengakses kepingan adalah mudah, memahami tingkah laku menghiris semula kepingan itu boleh menjadi rumit. Mari kita terokai coretan kod yang menggambarkan konsep ini:

package main

import "fmt"

func main() {
    a := make([]int, 5)
    printSlice("a", a)
    b := make([]int, 0, 5)
    printSlice("b", b)
    c := b[:2]
    printSlice("c", c)
    d := c[2:5]
    printSlice("d", d)
}

func printSlice(s string, x []int) {
    fmt.Printf("%s len=%d cap=%d %v\n",
        s, len(x), cap(x), x)
}

Kod ini mencipta kepingan a dengan panjang 5 dan kapasiti 5, diikuti oleh dua keping b dan c dengan panjang dan kapasiti 0 dan 2 masing-masing. Slice d kemudiannya dicipta sebagai kepingan semula c dengan indeks permulaan 2 dan indeks akhir 5.

Bahagian yang mengelirukan timbul apabila memerhatikan output:

a len=5 cap=5 [0 0 0 0 0]
b len=0 cap=5 []
c len=2 cap=5 [0 0] //why the capacity of c not 2 but 5 instead
d len=3 cap=3 [0 0 0]

Memahami Menghiris Semula

Apabila menghiris semula hirisan, adalah penting untuk mengingati bahawa kepingan adalah bukan salinan tatasusunan asasnya. Sebaliknya, ia adalah tetingkap yang merujuk sebahagian daripada tatasusunan.

• Dalam kes hirisan c, ia dicipta sebagai hirisan daripada dua elemen pertama bagi hirisan b. Oleh kerana b mempunyai kapasiti 5, kepingan c boleh dipanjangkan untuk memasukkan tiga elemen yang tinggal. Inilah sebabnya mengapa kapasitinya kekal pada 5.
• Slice d kemudian dicipta sebagai kepingan semula c dengan indeks permulaan 2. Ini bermakna d merujuk kepada elemen b dalam julat [2, 5). Memandangkan terdapat hanya tiga elemen yang tinggal dalam julat ini, panjang d ialah 3 dan kapasitinya ialah 3 (kerana ia sebahagian daripada kepingan yang lebih besar dengan jumlah kapasiti 5).

Penjelasan Lanjut

Kod berikut menunjukkan hubungan rapat antara dihiris semula kepingan:

func main() {
    b := make([]int, 0, 5)
    c := b[:2]
    d := c[1:5] // this is equivalent to d := b[1:5]
    d[0] = 1
    printSlice("c", c)
    printSlice("d", d)
}

Output:

c len=2 cap=5 [0 1] // modifying d has modified c
d len=4 cap=4 [1 0 0 0] 

Ini menunjukkan bahawa mengubah suai unsur slice d secara langsung mempengaruhi unsur slice c, mengesahkan bahawa kedua-dua kepingan berkongsi data asas yang sama.

Atas ialah kandungan terperinci Mengapa Menghiris Semula Go Slice Tidak Sentiasa Mengurangkan Kapasitinya?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!