Pengenalan terperinci kepada prinsip pelaksanaan dan penggunaan biasa hirisan golang

Bahasa Slice in Go ialah jujukan dinamik yang dilaksanakan berdasarkan tatasusunan, yang boleh meningkatkan atau mengurangkan saiznya secara dinamik semasa masa jalan dan menyokong operasi biasa pada data yang dihiris, seperti operasi tambah, sisip, sambung, salin dan potong . Artikel ini akan memperkenalkan prinsip pelaksanaan dan penggunaan biasa slice secara terperinci.

1. Struktur data Slice

Dalam bahasa Go, struktur data slice terdiri daripada tiga bahagian: penunjuk kepada tatasusunan asas, panjang kepingan dan kapasiti kepingan. Definisi khusus adalah seperti berikut:

type slice struct {

ptr *int  // 指向 slice 引用的底层数组
len int   // slice 的长度
cap int   // slice 的容量

}

Antaranya, pointer ptr menghala ke kedudukan permulaan tatasusunan asas, len mewakili panjang kepingan, dan penutup mewakili Kapasiti kepingan. Panjang hirisan mewakili bilangan elemen yang disimpan dalam hirisan pada masa ini, dan kapasiti hirisan mewakili bilangan elemen yang boleh disimpan dalam tatasusunan asas semasa.

2. Permulaan hirisan

Dalam bahasa Go, terdapat dua cara untuk mencipta hirisan: gunakan fungsi terbina dalam make() untuk mencipta hirisan, atau gunakan literal hirisan untuk mengisytiharkan dan memulakan hirisan secara langsung.

Gunakan fungsi terbina dalam make() untuk mencipta kepingan:

slice := make([]type, length, capacity)

Fungsi make() akan mencipta tatasusunan asas, dan mengembalikan kepingan yang menunjuk ke tatasusunan, yang parameternya masing-masing mewakili jenis elemen kepingan, panjang kepingan dan kapasiti kepingan. Antaranya, kapasiti hirisan boleh diabaikan Jika ia ditinggalkan, ia akan lalai pada panjang yang sama, menunjukkan bahawa kepingan itu tidak mempunyai ruang kosong.

Gunakan literal slice untuk mengisytiharkan dan memulakan hirisan:

slice := []type{elements}

Slice yang dibuat oleh literal slice tidak perlu menentukan panjang dan kapasiti, Pergi Bahasa secara automatik mengira panjang dan kapasiti kepingan berdasarkan bilangan elemen dalam kepingan.

3. Operasi asas kepingan

1 Dapatkan elemen dalam kepingan

Gunakan operator subskrip [] untuk mendapatkan elemen dengan subskrip yang ditentukan dalam kepingan. Subskrip adalah dari Bermula dari 0, nilai maksimum boleh len-1. Contohnya:

slice := []int{1, 2, 3}
fmt.Println(slice[0]) // Output: 1

2 🎜>

Anda boleh menggunakan kata kunci gelung dan julat untuk untuk melintasi elemen dalam kepingan. Contohnya:

slice := []int{1, 2, 3}

for index, value := range slice {

fmt.Printf("index:%d value:%d\n", index, value)

}

3 , Tambah elemen untuk menghiris

Gunakan fungsi terbina dalam append() untuk menambah elemen untuk menghiris. Fungsi append() akan mengembalikan kepingan baharu dan kepingan asal tidak akan diubah suai. Contohnya:

slice1 := []int{1, 2, 3}

slice2 := append(slice1, 4, 5)
fmt.Println(slice1) // Output: [ 1 2 3]
fmt.Println(slice2) //Output: [1 2 3 4 5]

4 Salin kepingan

Gunakan fungsi copy() terbina dalam untuk salin sekeping Salin ke sekeping lain. Contohnya:

slice1 := []int{1, 2, 3}

slice2 := make([]int, len(slice1))
copy(slice2, slice1)
fmt.Println(slice2) //Output: [1 2 3]

5. Slice slice

Gunakan operator slice [:] untuk menghiris hirisan bermula dari subskrip yang ditentukan. Hasil penghirisan ialah kepingan baharu, dan kepingan asal tidak akan diubah suai. Contohnya:

slice1 := []int{1, 2, 3}

slice2 := slice1[1:]
fmt.Println(slice2) // Output: [2 3]

4. Prinsip pelaksanaan slice

Slice dalam bahasa Go ialah jujukan dinamik yang dilaksanakan berdasarkan tatasusunan. Apabila hirisan dibuat, bahasa Go mencipta tatasusunan dan menghalakan ptr hirisan ke kedudukan permulaan tatasusunan. Pada mulanya, panjang kepingan ialah 0 dan kapasiti ialah panjang tatasusunan asas. Apabila append() dipanggil untuk menambahkan elemen, bahasa Go akan menyemak sama ada hirisan semasa mempunyai kapasiti yang mencukupi untuk menyimpan elemen baharu. Jika sudah mencukupi, ia akan menambah elemen baharu terus ke penghujung kepingan semasa ia tidak mencukupi, ia akan mengagihkan semula tatasusunan yang lebih besar Dan menyalin elemen dalam kepingan semasa ke tatasusunan baharu, dan kemudian menambah elemen baharu. Oleh itu, jika kapasiti kepingan tidak mencukupi, tatasusunan asas akan berubah, yang akan menjejaskan semua kepingan yang merujuk tatasusunan.

Apabila menghiris kepingan, bahasa Go akan mencipta kepingan baharu dan menghala ptr ke kedudukan permulaan kepingan dalam tatasusunan asal. Panjang dan kapasiti kepingan ditentukan oleh pengendali kepingan [:] dan parameter semasa membuat kepingan. Oleh itu, apabila menghiris, tatasusunan baharu tidak dibuat, tetapi tatasusunan asal digunakan semula.

5 Ringkasan

Artikel ini memperkenalkan prinsip pelaksanaan dan penggunaan umum slice dalam bahasa Go ialah struktur data yang penting untuk merealisasikan urutan dinamik dalam bahasa Go . Untuk Ia amat mudah untuk memproses data panjang boleh ubah. Mahir dalam kemahiran penggunaan dan prinsip pelaksanaan slice, anda boleh menulis program Go dengan lebih cekap dan mengoptimumkan prestasi kod.

Atas ialah kandungan terperinci Pengenalan terperinci kepada prinsip pelaksanaan dan penggunaan biasa hirisan golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!