Berapakah kapasiti dan panjang kepingan di Go?

Berapakah kapasiti dan panjang kepingan di Go?

Di Go, kepingan adalah struktur data yang fleksibel dan berkuasa yang dibina di atas array. Ia mempunyai dua sifat utama: panjang dan kapasiti.

• Panjang : Panjang kepingan adalah bilangan elemen yang terkandung di dalamnya. Ia mewakili saiz kepingan yang boleh anda akses secara langsung. Anda boleh mendapatkan panjang kepingan menggunakan fungsi len() .
• Kapasiti : Kapasiti kepingan adalah bilangan maksimum elemen yang boleh dipegang oleh kepingan tanpa memperuntukkan memori baru. Ia mewakili jumlah ruang yang diperuntukkan untuk pelbagai asas. Anda boleh mendapatkan kapasiti kepingan menggunakan fungsi cap() .

Berikut adalah contoh mudah yang menunjukkan penggunaan len() dan cap() :

 <code class="go">package main import "fmt" func main() { s := make([]int, 5, 10) // Creates a slice with length 5 and capacity 10 fmt.Printf("Length: %d, Capacity: %d\n", len(s), cap(s)) }</code>

Dalam contoh ini, Slice s mempunyai panjang 5 dan kapasiti 10.

Bagaimanakah saya dapat mengubah suai kapasiti kepingan di Go?

Kapasiti kepingan di Go tidak berubah sebaik sahaja ia dibuat. Anda tidak boleh mengubah suai kapasiti kepingan yang sedia ada. Walau bagaimanapun, anda boleh membuat kepingan baru dengan kapasiti yang berbeza menggunakan beberapa kaedah:

1. Menggunakan fungsi make : Anda boleh membuat kepingan baru dengan panjang dan kapasiti yang ditentukan.

    <code class="go">newSlice := make([]int, len(oldSlice), newCapacity) copy(newSlice, oldSlice)</code>

   Salin selepas log masuk

   Salin selepas log masuk

2. Menggunakan fungsi append : Apabila anda menambah elemen ke kepingan, GO akan secara automatik meningkatkan kapasiti jika perlu.

    <code class="go">s := []int{1, 2, 3} s = append(s, 4, 5, 6) // This might increase the capacity if needed</code>

   Salin selepas log masuk

3. Menggunakan fungsi copy : Anda boleh menyalin kandungan kepingan lama ke kepingan baru dengan kapasiti yang berbeza.

    <code class="go">newSlice := make([]int, len(oldSlice), newCapacity) copy(newSlice, oldSlice)</code>

   Salin selepas log masuk

   Salin selepas log masuk

Inilah contoh untuk menggambarkan kaedah ini:

 <code class="go">package main import "fmt" func main() { s := []int{1, 2, 3} // Length: 3, Capacity: 3 fmt.Printf("Original: Length: %d, Capacity: %d\n", len(s), cap(s)) // Using make and copy newSlice := make([]int, len(s), 10) copy(newSlice, s) fmt.Printf("After make and copy: Length: %d, Capacity: %d\n", len(newSlice), cap(newSlice)) // Using append s = append(s, 4, 5, 6, 7) fmt.Printf("After append: Length: %d, Capacity: %d\n", len(s), cap(s)) }</code>

Apa yang berlaku apabila saya cuba mengakses indeks di luar panjang kepingan di Go?

Di Go, cuba mengakses indeks di luar panjang kepingan akan menghasilkan panik runtime. Ini kerana panjang kepingan mentakrifkan julat indeks yang anda dapat mengakses dengan selamat.

Inilah contoh:

 <code class="go">package main import "fmt" func main() { s := []int{1, 2, 3} // Length: 3 fmt.Println(s[0]) // This is valid fmt.Println(s[3]) // This will cause a runtime panic }</code>

Mesej ralat yang akan anda lihat adalah seperti ini:

 <code>panic: runtime error: index out of range [3] with length 3</code>

Panik ini berlaku kerana Indeks 3 berada di luar batas kepingan, yang panjangnya 3.

Apakah perbezaan antara panjang dan kapasiti kepingan di Go?

Panjang dan kapasiti kepingan dalam pergi melayani tujuan yang berbeza dan mempunyai peranan yang berbeza:

• Panjang : Panjang kepingan adalah bilangan elemen yang kini dipegangnya. Ia menentukan indeks yang sah kepingan. Anda boleh mengakses unsur -unsur kepingan sehingga len(s) - 1 , dan cuba mengakses indeks di luar ini akan menghasilkan panik runtime.
• Kapasiti : Kapasiti kepingan adalah jumlah elemen yang boleh dipegang oleh array yang boleh dipegang. Ia mentakrifkan panjang potensi maksimum kepingan yang dapat dicapai tanpa perlu memperuntukkan memori baru. Anda boleh meningkatkan panjang kepingan sehingga keupayaan menggunakan fungsi append tanpa mencetuskan pengagihan semula memori.

Inilah ringkasan perbezaan mereka:

• Panjang :

  • Mentakrifkan bilangan elemen semasa dalam kepingan.
  • Diakses melalui len(s) .
  • Menentukan julat indeks yang sah.

• Kapasiti :

  • Mendefinisikan bilangan maksimum elemen yang boleh dipegang oleh array asas.
  • Diakses melalui cap(s) .
  • Menunjukkan potensi pertumbuhan kepingan tanpa pengagihan semula ingatan.

Berikut adalah contoh yang menggambarkan konsep -konsep ini:

 <code class="go">package main import "fmt" func main() { s := make([]int, 3, 5) // Length: 3, Capacity: 5 fmt.Printf("Initial: Length: %d, Capacity: %d\n", len(s), cap(s)) s = append(s, 4) // Length: 4, Capacity: 5 fmt.Printf("After first append: Length: %d, Capacity: %d\n", len(s), cap(s)) s = append(s, 5) // Length: 5, Capacity: 5 fmt.Printf("After second append: Length: %d, Capacity: %d\n", len(s), cap(s)) s = append(s, 6) // Length: 6, Capacity might increase fmt.Printf("After third append: Length: %d, Capacity: %d\n", len(s), cap(s)) }</code>

Dalam contoh ini, kepingan bermula dengan panjang 3 dan kapasiti 5. Apabila kita menambahkan unsur -unsur, panjangnya meningkat sehingga mencapai kapasiti. Kapasiti boleh meningkat apabila kita melebihi kapasiti asal.

Atas ialah kandungan terperinci Berapakah kapasiti dan panjang kepingan di Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!