Slices: Tulang Belakang Pergi!

Baiklah, mari kita selami salah satu ciri Go yang paling serba boleh dan penting - kepingan. Jika anda datang daripada bahasa lain, anda mungkin menganggap kepingan sebagai serupa dengan tatasusunan. Dan, ya, mereka mempunyai beberapa persamaan, tetapi kepingan membawa lebih banyak kuasa, fleksibiliti dan sihir khusus Go ke meja! ?

Apa itu Slice? ?

Dalam Go, kepingan ialah jenis yang membolehkan anda bekerja dengan senarai elemen (seperti tatasusunan), tetapi ia dinamik, bermakna ia boleh membesar dan mengecut mengikut keperluan. Tidak perlu menentukan panjang tetap di hadapan seperti yang anda lakukan dengan tatasusunan. Mereka disokong oleh tatasusunan di bawah hud, tetapi anda mendapat lebih banyak kawalan. Anggap mereka sebagai adik beradik tatasusunan yang lebih sejuk dan lebih fleksibel.

Jadi, sekeping dalam Go sebenarnya ialah "tetingkap" pada tatasusunan asas. Anda boleh menukar saiz tetingkap ini dengan membesar atau mengecilkannya – dan ia sehalus menghiris sekeping kek. ?

Mencipta Slice ?
Mencipta kepingan adalah agak mudah:

// Using a literal
numbers := []int{1, 2, 3, 4, 5}

// Using the make function
sliceOfStrings := make([]string, 5) // a slice of 5 strings, each 

dimulakan kepada rentetan kosong
Dengan make, anda memberitahu Go untuk membuat kepingan dengan panjang tertentu tetapi disokong oleh tatasusunan yang diuruskannya untuk anda. Jadi anda tidak perlu risau tentang butiran peruntukan memori. ?

Panjang dan Kapasiti ?

Dua konsep penting dalam kepingan ialah panjang dan kapasiti. Panjang ialah bilangan elemen pada masa ini dalam kepingan, manakala kapasiti ialah jumlah bilangan elemen yang boleh disimpan sebelum ia perlu mengubah saiz.

numbers := []int{1, 2, 3}
fmt.Println(len(numbers)) // 3
fmt.Println(cap(numbers)) // 3 (same as length here)

Apabila anda mula menambahkan item, Go akan menggandakan kapasiti apabila ia penuh, jadi anda tidak perlu risau tentang terkena siling.

numbers = append(numbers, 4)
fmt.Println(len(numbers)) // 4
fmt.Println(cap(numbers)) // probably 6 now, depending on Go’s growth 

corak
Melampirkan pada Slices: Go’s Built-In Magic ?✨
Menambah elemen pada kepingan adalah semudah pai dengan fungsi append Go. Anda boleh menambah satu atau lebih elemen sekali gus dan Go akan mengendalikan semua saiz semula dan bahan memori untuk anda.

numbers := []int{1, 2, 3}
numbers = append(numbers, 4, 5, 6) // Adding multiple elements at once
fmt.Println(numbers) // [1 2 3 4 5 6]

Ciri saiz semula automatik ini menjadikan hirisan sangat berguna, terutamanya jika anda tidak tahu berapa besar senarai anda akan dapat.

Menghiris Sekeping??

Menghiris dalam Go sebenarnya adalah tempat yang menjadi sangat menyeronokkan. Anda boleh membuat "sub-slice" bagi kepingan sedia ada tanpa menyalin elemen.

numbers := []int{10, 20, 30, 40, 50}
subSlice := numbers[1:4] // Just takes a "slice" of the original slice
fmt.Println(subSlice) // [20 30 40]

Dalam nombor[1:4], indeks pertama (1) adalah inklusif, dan indeks terakhir (4) adalah eksklusif. Anda berakhir dengan elemen pada kedudukan 1, 2 dan 3, tetapi bukan 4.

Sub keping ini masih berkongsi tatasusunan asas yang sama dengan kepingan asal, jadi perubahan pada satu akan mempengaruhi yang lain:

subSlice[0] = 25
fmt.Println(numbers) // [10 25 30 40 50]
fmt.Println(subSlice) // [25 30 40]

Untuk mengelakkan sebarang perubahan yang tidak diingini, anda boleh menggunakan salinan untuk mencipta versi hirisan bebas:

// Using a literal
numbers := []int{1, 2, 3, 4, 5}

// Using the make function
sliceOfStrings := make([]string, 5) // a slice of 5 strings, each 

Menukar Kapasiti dengan tambahan ?

Jika anda memerlukan kepingan yang lebih besar daripada kapasiti semasanya, tambah akan membuat tatasusunan baharu yang lebih besar secara automatik di latar belakang dan menyalin semuanya. Ini adalah sangat cekap dan sebahagian besar daripada apa yang menjadikan hirisan hebat. Apabila append mencipta tatasusunan baharu, ia memperuntukkan dua kali ganda kapasiti sebelumnya – memberi anda ruang untuk berkembang!

Menghiris dan Kecekapan Memori ?

Inilah sedikit rahsia Go: walaupun menghiris sangat berkuasa, ia kadangkala boleh menyebabkan kebocoran ingatan jika anda tidak berhati-hati. Memandangkan hirisan merujuk kepada tatasusunan asas yang sama, tatasusunan itu mungkin kekal dalam ingatan walaupun anda hanya menggunakan sebahagian kecil daripadanya.

Contohnya:

numbers := []int{1, 2, 3}
fmt.Println(len(numbers)) // 3
fmt.Println(cap(numbers)) // 3 (same as length here)

Dalam kes seperti ini, sebaiknya gunakan salinan untuk mencipta kepingan bebas yang tulen yang hanya mengandungi data yang anda perlukan, membebaskan baki memori.

numbers = append(numbers, 4)
fmt.Println(len(numbers)) // 4
fmt.Println(cap(numbers)) // probably 6 now, depending on Go’s growth 

Hirisan Pelbagai Dimensi ??

Memerlukan lebih daripada satu dimensi? Anda juga boleh membuat kepingan berbilang dimensi! Ini boleh berguna untuk perkara seperti grid atau jadual. Hanya isytiharkan sekeping hirisan:

numbers := []int{1, 2, 3}
numbers = append(numbers, 4, 5, 6) // Adding multiple elements at once
fmt.Println(numbers) // [1 2 3 4 5 6]

Setiap "baris" adalah kepingan itu sendiri, jadi anda boleh membesarkannya secara bebas jika perlu.

numbers := []int{10, 20, 30, 40, 50}
subSlice := numbers[1:4] // Just takes a "slice" of the original slice
fmt.Println(subSlice) // [20 30 40]

Slice Nil ?

Kepingan kosong hanyalah kepingan yang belum dimulakan lagi. Ia mempunyai panjang dan kapasiti sifar tetapi masih boleh digunakan dengan fungsi seperti append tanpa panik.

subSlice[0] = 25
fmt.Println(numbers) // [10 25 30 40 50]
fmt.Println(subSlice) // [25 30 40]

Apabila anda menambahkan kepingan kosong, Go hanya memulakannya untuk anda secara automatik. Ia adalah helah yang kemas untuk meningkatkan lengan anda.

Perangkap dan Amalan Terbaik ?
Tonton Memori Dikongsi: Ingat, kepingan berkongsi memori dengan tatasusunan asal. Ini bagus untuk prestasi, tetapi berhati-hati semasa menghiris bahagian tatasusunan yang besar untuk mengelakkan menyimpan data yang tidak diperlukan dalam ingatan.

Berhati-hati Mengubah Saiz: Apabila anda menambah, Go mungkin perlu mencipta tatasusunan asas baharu jika kapasiti semasa penuh. Ini boleh menjadi lebih cekap daripada melakukan banyak saiz semula kecil, tetapi ambil perhatian tentang overhed jika anda berurusan dengan set data yang besar.

Elakkan Pengoptimuman Pramatang: Go mengendalikan banyak peruntukan memori dan mengubah saiz secara automatik dengan kepingan. Selalunya, cuba menguruskan butiran ini boleh menyebabkan kod anda lebih kemas dan kurang cekap. Percayai mekanik slice Go untuk melakukan perkara yang betul dalam kebanyakan kes.

Atas ialah kandungan terperinci Slices: Tulang Belakang Pergi!. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!