Penjelasan terperinci tentang cara menggunakan tatasusunan Golang

Dalam beberapa tahun kebelakangan ini, Golang (bahasa Go) semakin popular di kalangan pembangun. Golang bukan sahaja mempunyai kecekapan dan kebolehpercayaan bahasa C, tetapi juga mempunyai kesederhanaan dan kemudahan pembelajaran bahasa Python. Antaranya, tatasusunan ialah jenis data yang penting di Golang Dalam artikel ini, kami akan memberi tumpuan kepada penggunaan tatasusunan Golang.

1. Definisi tatasusunan

Mengisytiharkan tatasusunan dalam Golang memerlukan menentukan jenis dan panjang tatasusunan Sintaksnya adalah seperti berikut:

var arr [长度]类型

Sebagai contoh, mengisytiharkan tatasusunan dengan panjang 5 tatasusunan jenis int:

var arr [5]int

Pada masa ini, Golang akan memperuntukkan ruang untuk kita dan memulakannya mengikut nilai lalai jenis (nilai lalai jenis int ialah 0), seperti berikut:

[0 0 0 0 0]

Anda juga boleh menggunakan pemula untuk menetapkan nilai awal kepada tatasusunan, contohnya:

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

atau ia boleh disingkatkan sebagai:

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

Kedua-dua kaedah di atas boleh mencipta tatasusunan dengan panjang Tatasusunan 5, dan menetapkan nilai awal kepada 1, 2, 3, 4, 5.

Jika tiada had tetap pada panjang tatasusunan, anda boleh menggunakan penghirisan.

2. Operasi asas tatasusunan

1 Dapatkan panjang tatasusunan

Dalam Golang, anda boleh menggunakan fungsi len() untuk mendapatkan panjang tatasusunan. , sebagai contoh:

arr := [5]int{1, 2, 3, 4, 5}
length := len(arr)
fmt.Println(length) //输出5

2 Akses elemen tatasusunan

Di Golang, anda boleh menggunakan subskrip tatasusunan untuk mengakses elemen tatasusunan dan subskrip tatasusunan mula dikira dari 0. Contohnya:

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

3. Ubah suai elemen tatasusunan

Di Golang, anda boleh mengubah suai nilai elemen tatasusunan dengan melanggan, contohnya:

arr := [5]int{1, 2, 3, 4, 5}
arr[0] = 100
fmt.Println(arr) //输出[100 2 3 4 5]

3 . Tatasusunan berbilang dimensi

Di Golang, anda juga boleh menggunakan tatasusunan berbilang dimensi. Tatasusunan multidimensi ialah tatasusunan di mana satu elemen ialah tatasusunan. Sama seperti tatasusunan satu dimensi, sintaks untuk mengisytiharkan tatasusunan dua dimensi adalah seperti berikut:

var arr [长度1][长度2]类型

Contohnya:

var arr [4][2]int

Operasi di atas mencipta dua dimensi tatasusunan dengan 4 baris dan 2 lajur.

Akses dan pengubahsuaian tatasusunan berbilang dimensi juga serupa dengan tatasusunan satu dimensi, menggunakan subskrip, contohnya:

arr := [4][2]int{{1, 2}, {3, 4}, {5, 6}, {7, 8}}
fmt.Println(arr[0][0]) //输出1
fmt.Println(arr[1][1]) //输出4 
arr[2][1] = 10
fmt.Println(arr) //输出[[1 2] [3 4] [5 10] [7 8]]

4. Traversal tatasusunan

Dalam Elemen Golang, Tatasusunan boleh diulang dengan mudah menggunakan gelung for. Contohnya:

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

Atau anda boleh menggunakan kata kunci julat untuk melintasi:

arr := [5]int{1, 2, 3, 4, 5}
for index, value := range arr {
    fmt.Printf("arr[%d] = %d \n", index, value)
}

Kedua-dua kaedah di atas boleh melintasi elemen dalam tatasusunan output.

5. Tatasusunan sebagai parameter

Dalam Golang, tatasusunan juga boleh digunakan sebagai parameter fungsi. Contohnya:

func sum(arr [5]int) int {
    var sum int
    for _, value := range arr {
        sum += value
    }
    return sum
}

func main() {
    arr := [5]int{1, 2, 3, 4, 5}
    fmt.Println(sum(arr))
}

Dalam kod di atas, fungsi sum() menerima tatasusunan jenis int dengan panjang 5 sebagai parameter dan mengembalikan jumlah tatasusunan ini.

6. Tukar slice kepada array

Slice ialah satu lagi jenis data yang sangat penting dalam Golang dan boleh dikembangkan secara dinamik. Jika anda perlu menukar Slice kepada tatasusunan, anda boleh menggunakan fungsi copy(), contohnya:

slice := []int{1, 2, 3, 4, 5}
var arr [5]int
copy(arr[:], slice)
fmt.Println(arr) //输出[1 2 3 4 5]

7. Ringkasan

Artikel ini memperkenalkan pengetahuan asas tatasusunan Golang , termasuk definisi tatasusunan, Operasi asas, tatasusunan berbilang dimensi, traversal, tatasusunan sebagai parameter, menukar kepingan kepada tatasusunan, dsb. Jika anda seorang pembangun Golang, mempelajari dan menguasai penggunaan tatasusunan akan membantu meningkatkan kemahiran pengaturcaraan dan kecekapan pembangunan anda.

Atas ialah kandungan terperinci Penjelasan terperinci tentang cara menggunakan tatasusunan Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!