Bagaimana untuk menggunakan tatasusunan dalam Go?

Go ialah bahasa pengaturcaraan ditaip kuat yang menyediakan tatasusunan untuk menyimpan dan mengurus satu siri data. Tatasusunan ialah struktur data panjang tetap dan jenis yang sama yang boleh ditakrifkan dan digunakan dengan mudah dalam Go.

Dalam artikel ini, kami akan meneroka cara menggunakan tatasusunan dalam Go dan mempelajari tentang beberapa operasi tatasusunan biasa.

Tentukan Tatasusunan

Untuk menentukan tatasusunan dalam Go, kita perlu menentukan jenis dan panjang tatasusunan. Panjang tatasusunan mestilah integer dan tidak boleh ditentukan oleh pembolehubah atau pengiraan masa jalan.

Begini cara anda mentakrifkan tatasusunan integer dengan panjang 5:

var arr [5]int

Kod di atas mencipta pembolehubah tatasusunan dipanggil arr yang mempunyai 5 elemen integer, satu untuk setiap elemen Semua dimulakan kepada 0. Kita boleh mengakses elemen dalam tatasusunan mengikut indeks Nilai indeks bermula dari 0 dan mencapai maksimum panjang tatasusunan - 1.

Untuk memulakan tatasusunan, kita boleh menggunakan yang berikut:

arr := [5]int{1, 2, 3, 4, 5}

Ini akan mencipta tatasusunan integer dengan panjang 5, dengan elemen dimulakan masing-masing kepada 1, 2, 3, 4, 5.

Kami juga boleh menggunakan sintaks [...] agar Go mengira panjang tatasusunan secara automatik berdasarkan elemen yang disediakan, seperti yang ditunjukkan di bawah:

arr := [...]int{1, 2, 3, 4, 5}

Kod di atas mempunyai kesan yang sama seperti coretan kod sebelumnya .

Melintasi tatasusunan

Untuk melintasi tatasusunan, anda boleh menggunakan gelung for. Berikut ialah contoh yang berulang melalui tatasusunan integer dan mencetak setiap elemen.

arr := [5]int{1, 2, 3, 4, 5}

for i := 0; i < len(arr); i++ {
    fmt.Println(arr[i])
}

Dalam contoh ini, kami menggunakan gelung for untuk pergi dari 0 ke panjang tatasusunan, melelang melalui keseluruhan tatasusunan, dan kemudian mencetak setiap elemen.

Slice

Slice ialah satu lagi konsep penting dalam Go Ia ialah struktur data panjang dinamik yang merujuk tatasusunan asas. Menghiris menyediakan cara yang mudah untuk mengendalikan data panjang berubah-ubah, yang lebih fleksibel daripada menggunakan tatasusunan panjang tetap.

Dalam Go, anda boleh menggunakan kaedah berikut untuk mencipta hirisan:

arr := []int{1, 2, 3, 4, 5}

Tidak seperti tatasusunan, panjang hirisan boleh diubah semasa masa jalan, yang memberikan kita cara yang mudah untuk Mengendalikan data panjang berubah-ubah.

Tambah elemen pada kepingan

Kita boleh menambah elemen pada kepingan menggunakan fungsi tambah. Fungsi append menambah elemen pada kepingan dan mengembalikan kepingan baharu yang mengandungi elemen tambahan. Di bawah ialah contoh menambah elemen baharu pada kepingan.

arr := []int{1, 2, 3}
arr = append(arr, 4, 5, 6)

Dalam contoh kod di atas, kami menambah tiga elemen baharu pada kepingan dan panjang akhir kepingan menjadi 6. Fungsi tambah membenarkan menambah berbilang elemen serentak, setiap satu dipisahkan dengan koma.

Padam elemen dalam kepingan

Kita boleh menggunakan pengendali kepingan [:] dalam Pergi untuk memadam elemen dalam kepingan. Di bawah ialah contoh mengalih keluar elemen daripada kepingan dan mengembalikan kepingan baharu.

arr := []int{1, 2, 3, 4, 5}
arr = append(arr[:2], arr[3:]...)

Dalam contoh di atas, kami menggabungkan dua elemen pertama dengan dua elemen terakhir menggunakan operator penghirisan, yang mengalih keluar elemen dengan indeks 2 dan mengembalikan elemen baharu dengan panjang 4 kepingan.

Menyalin Slices

Kita boleh menggunakan fungsi copy terbina dalam yang disediakan oleh Pergi untuk menyalin kepingan. Di bawah ialah contoh menggunakan fungsi copy untuk menyalin kepingan.

arr := []int{1, 2, 3}
copyArr := make([]int, len(arr))
copy(copyArr, arr)

Dalam contoh di atas, kita mula-mula menggunakan fungsi make untuk mencipta kepingan kosong dengan panjang yang sama dengan arr, dan kemudian gunakan fungsi copy untuk menyalin elemen dalam arr ke copyArr tengah.

Ringkasan

Dalam artikel ini, kami membincangkan cara menggunakan tatasusunan dan kepingan dalam Go. Tatasusunan ialah struktur data panjang tetap, manakala hirisan ialah struktur data jenis rujukan panjang dinamik. Kami belajar cara untuk mengulang tatasusunan, menambah dan mengalih keluar elemen pada kepingan dan menyalin kepingan. Operasi ini menyediakan alat asas kepada pengaturcara Go untuk memproses data dan merupakan pengetahuan asas yang diperlukan untuk membina aplikasi yang kompleks.

Atas ialah kandungan terperinci Bagaimana untuk menggunakan tatasusunan dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!