golang remove array

Dalam bahasa Go, tatasusunan ialah struktur data panjang tetap Setelah dibuat, panjangnya tidak boleh diubah. Tetapi dalam beberapa kes, kita perlu meningkatkan atau mengurangkan elemen dalam tatasusunan secara dinamik. Apakah yang perlu kita lakukan pada masa ini? Malah, bahasa Go menyediakan beberapa kaedah untuk mengalih keluar elemen daripada tatasusunan Artikel ini akan memperkenalkan beberapa daripadanya.

1. Menggunakan kepingan

Slice ialah tatasusunan dinamik dalam bahasa Go, yang diperoleh dengan memotong tatasusunan. Walaupun lapisan asas hirisan ialah tatasusunan, panjangnya tidak tetap dan elemen boleh ditambah atau dikurangkan secara dinamik mengikut keperluan. Oleh itu, menggunakan penghirisan untuk mengalih keluar elemen daripada tatasusunan adalah pendekatan biasa.

Kita boleh menggunakan fungsi terbina dalam menghiris append() untuk mengalih keluar elemen daripada tatasusunan. Katakan anda ingin mengalih keluar arrelemen tatasusunan idx Anda boleh menghiris tatasusunan terlebih dahulu kepada dua bahagian, ambil elemen untuk dipadamkan daripada tatasusunan, kemudian sambungkan dua bahagian itu bersama-sama, dan akhirnya simpan hasilnya. ke dalam tatasusunan asal.

Berikut ialah contoh kod:

func removeItem(arr []int, idx int) []int {
    return append(arr[:idx], arr[idx+1:]...)
}

arr := []int{1, 2, 3, 4, 5}
idx := 2
arr = removeItem(arr, idx)
fmt.Println(arr) // [1 2 4 5]

Dalam kod ini, kami menggunakan fungsi terbina dalam append() untuk mengalih keluar elemen idxdari hirisan dan mengembalikan yang baharu selepas dialih keluar Menghiris membahagikan tatasusunan asal arr kepada dua bahagian, iaitu arr[:idx] dan arr[idx+1:]. Kedua-dua bahagian kemudiannya disambungkan melalui fungsi append(), dan hasil akhir ialah tatasusunan baharu selepas mengalih keluar elemen daripada tatasusunan asal.

2 Gunakan aksara ruang kosong

Cara lain untuk mengalih keluar elemen tatasusunan ialah menggunakan aksara ruang putih dalam bahasa Go. Watak ruang putih sebenarnya ialah pengecam khas yang digunakan untuk menunjukkan bahawa apabila kita menerima nilai yang dikembalikan oleh fungsi, kita tidak perlu menggunakan nilai pulangan sebenarnya. Menggunakan aksara ruang putih dalam tatasusunan boleh menetapkan elemen dalam tatasusunan kepada kosong untuk mencapai kesan pengalihan keluar. Contoh

adalah seperti berikut:

arr := []int{1, 2, 3, 4, 5}
idx := 2
arr[idx] = arr[len(arr)-1]
arr[len(arr)-1] = 0
arr = arr[:len(arr)-1]
fmt.Println(arr) // [1 2 4 5]

Di sini, gunakan aksara ruang putih 0 untuk menetapkan elemen dengan indeks len(arr)-1 kepada kosong dan padamkan elemen kosong ini dari penghujung tatasusunan, dengan itu mencapai penyingkiran kesan Elemen.

Perlu diingat bahawa walaupun kaedah ini boleh mengalih keluar elemen, ia tidak akan mengubah panjang tatasusunan, jadi kita perlu berhati-hati dalam operasi seterusnya.

3 Gunakan fungsi salin

Fungsi terbina dalam bahasa Go copy() Anda boleh menyalin satu kepingan ke kepingan lain, atau anda boleh menyalin sebahagian daripada tatasusunan ke bahagian lain tatasusunan yang sama. Oleh itu, kita boleh menggunakan fungsi copy() untuk mengalih keluar elemen daripada tatasusunan. Contoh

adalah seperti berikut:

arr := []int{1, 2, 3, 4, 5}
idx := 2
copy(arr[idx:], arr[idx+1:])
arr[len(arr)-1] = 0
arr = arr[:len(arr)-1]
fmt.Println(arr) // [1 2 4 5]

Dalam kod ini, kita mula-mula menggunakan fungsi copy() untuk menyalin elemen bermula dari arr[idx+1:] ke arr[idx:], dengan itu mengalihkan idx buang unsur. Kemudian tetapkan elemen terakhir dalam tatasusunan kepada kosong, dan akhirnya padamkan elemen kosong melalui penghirisan.

Perlu diingatkan bahawa kerana tatasusunan ialah jenis nilai, bukan jenis rujukan, kita perlu menggunakan penghirisan untuk menyalin tatasusunan, dan kemudian menyimpan hasilnya ke tatasusunan asal selepas pengubahsuaian.

4 Gunakan gelung

Cara terakhir untuk mengalih keluar elemen tatasusunan ialah menggunakan gelung. Kita boleh mengalih keluar elemen dengan menggerakkannya ke belakang melalui gelung.

Contohnya adalah seperti berikut:

arr := []int{1, 2, 3, 4, 5}
idx := 2
for i := idx + 1; i < len(arr); i++ {
    arr[i-1] = arr[i]
}
arr = arr[:len(arr)-1]
fmt.Println(arr) // [1 2 4 5]

Di sini, ia menggelung setiap elemen selepas elemen yang perlu dipadamkan, menggerakkannya ke hadapan sedikit, dan akhirnya memadamkan elemen yang berlebihan. Kaedah ini lebih rumit, tetapi ia juga sangat praktikal.

Ringkasan

Mengalih keluar elemen tatasusunan ialah operasi asas dalam bahasa Go menyediakan pelbagai kaedah yang mudah dan cekap untuk melaksanakan operasi ini. Anda boleh mengalih keluar elemen dengan mudah daripada tatasusunan, sama ada menggunakan penghirisan, ruang kosong, fungsi salin atau menggunakan gelung. Mengikut situasi sebenar, kita boleh memilih kaedah yang paling sesuai untuk mencapai tujuan.

Atas ialah kandungan terperinci golang remove array. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!