Apa cara ringkas untuk membuat potongan 2D di Go?

Saya mempelajari Go dengan mengikuti A Tour of Go . Salah satu latihan di sana meminta saya membuat potongan 2D dybaris dan dxkolom berisi uint8. Pendekatan saya saat ini, yang berhasil, adalah ini:

a:= make([][]uint8, dy)       // initialize a slice of dy slices
for i:=0;i<dy;i++ {
    a[i] = make([]uint8, dx)  // initialize a slice of dx unit8 in each of dy slices
}

Saya pikir iterasi melalui setiap potongan untuk menginisialisasi itu terlalu bertele-tele. Dan jika potongan memiliki lebih banyak dimensi, kodenya akan menjadi sulit digunakan. Apakah ada cara ringkas untuk menginisialisasi irisan 2D (atau n-dimensi) di Go?

Tidak ada cara yang lebih ringkas, apa yang Anda lakukan adalah cara yang "benar"; karena irisan selalu satu dimensi tetapi dapat disusun untuk membangun objek berdimensi lebih tinggi. Lihat pertanyaan ini untuk lebih jelasnya: Pergi: Bagaimana representasi memori array dua dimensi .

Satu hal yang dapat Anda sederhanakan adalah dengan menggunakan for rangekonstruksi:

a := make([][]uint8, dy)
for i := range a {
    a[i] = make([]uint8, dx)
}

Perhatikan juga bahwa jika Anda menginisialisasi potongan Anda dengan literal komposit , Anda mendapatkan ini secara "gratis", misalnya:

a := [][]uint8{
    {0, 1, 2, 3},
    {4, 5, 6, 7},
}
fmt.Println(a) // Output is [[0 1 2 3] [4 5 6 7]]

Ya, ini ada batasnya karena Anda harus menghitung semua elemen; tetapi ada beberapa trik, yaitu Anda tidak harus menghitung semua nilai, hanya nilai yang bukan nilai nol dari jenis elemen potongan. Untuk detail selengkapnya tentang ini, lihat Item yang dimasukkan dalam inisialisasi larik golang .

Misalnya jika Anda menginginkan potongan di mana 10 elemen pertama adalah nol, lalu mengikuti 1dan 2, itu bisa dibuat seperti ini:

b := []uint{10: 1, 2}
fmt.Println(b) // Prints [0 0 0 0 0 0 0 0 0 0 1 2]

Perhatikan juga bahwa jika Anda menggunakan array, bukan irisan , ini dapat dibuat dengan sangat mudah:

c := [5][5]uint8{}
fmt.Println(c)

Outputnya adalah:

[[0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0]]

Dalam kasus array, Anda tidak perlu mengulang array "luar" dan menginisialisasi array "dalam", karena array bukanlah deskriptor tetapi nilai. Lihat entri blog Array, irisan (dan string): Mekanisme 'tambahkan' untuk detail selengkapnya.

Coba contoh di Go Playground .

Ada dua cara menggunakan irisan untuk membuat matriks. Mari kita lihat perbedaan di antara keduanya.

Metode pertama:

matrix := make([][]int, n)
for i := 0; i < n; i++ {
    matrix[i] = make([]int, m)
}

Metode kedua:

matrix := make([][]int, n)
rows := make([]int, n*m)
for i := 0; i < n; i++ {
    matrix[i] = rows[i*m : (i+1)*m]
}

Berkenaan dengan metode pertama, melakukan makepanggilan berturut-turut tidak memastikan bahwa Anda akan berakhir dengan matriks yang berdekatan, jadi Anda mungkin memiliki matriks yang terbagi dalam memori. Mari kita pikirkan contoh dengan dua rutinitas Go yang dapat menyebabkan ini:

1. Rutin # 0 berjalan make([][]int, n)untuk mendapatkan memori yang dialokasikan matrix, mendapatkan bagian memori dari 0x000 hingga 0x07F.
2. Kemudian, ia memulai pengulangan dan melakukan baris pertama make([]int, m), dari 0x080 ke 0x0FF.
3. Pada iterasi kedua itu didahului oleh penjadwal.
4. Penjadwal memberikan prosesor ke rutinitas # 1 dan mulai berjalan. Yang ini juga menggunakan make(untuk tujuannya sendiri) dan berpindah dari 0x100 ke 0x17F (tepat di sebelah baris pertama rutinitas # 0).
5. Setelah beberapa saat, itu akan didahului dan rutinitas # 0 mulai berjalan kembali.
6. Itu make([]int, m)sesuai dengan iterasi loop kedua dan beralih dari 0x180 ke 0x1FF untuk baris kedua. Pada titik ini, kami sudah mendapatkan dua baris yang terbagi.

Dengan metode kedua, rutin dilakukan make([]int, n*m)untuk mendapatkan semua matriks dialokasikan dalam satu bagian, memastikan kedekatan. Setelah itu, diperlukan perulangan untuk memperbarui penunjuk matriks ke subleks yang sesuai dengan setiap baris.

Anda dapat bermain dengan kode yang ditunjukkan di atas di Go Playground untuk melihat perbedaan dalam memori yang ditetapkan dengan menggunakan kedua metode tersebut. Perhatikan bahwa saya runtime.Gosched()hanya menggunakan dengan tujuan menghasilkan prosesor dan memaksa penjadwal untuk beralih ke rutinitas lain.

Yang mana yang akan digunakan? Bayangkan kasus terburuk dengan metode pertama, yaitu setiap baris tidak berada di memori berikutnya ke baris lain. Kemudian, jika program Anda melakukan iterasi melalui elemen matriks (untuk membaca atau menulisnya), mungkin akan ada lebih banyak cache yang hilang (karenanya latensi lebih tinggi) dibandingkan dengan metode kedua karena lokalitas data yang lebih buruk. Di sisi lain, dengan metode kedua, tidak mungkin mendapatkan satu bagian memori yang dialokasikan untuk matriks, karena fragmentasi memori (potongan tersebar di seluruh memori), meskipun secara teoritis mungkin ada cukup memori kosong untuk itu. .

Oleh karena itu, kecuali jika ada banyak fragmentasi memori dan matriks yang akan dialokasikan cukup besar, Anda akan selalu ingin menggunakan metode kedua untuk memanfaatkan lokalitas data.

Dalam jawaban sebelumnya kami tidak mempertimbangkan situasi ketika panjang awalnya tidak diketahui. Untuk kasus ini, Anda dapat menggunakan logika berikut untuk membuat matriks

items := []string{"1.0", "1.0.1", "1.0.2", "1.0.2.1.0"}
mx := make([][]string, 0)
for _, item := range items {
    ind := strings.Count(item, ".")
    for len(mx) < ind+1 {
        mx = append(mx, make([]string, 0))
    }
    mx[ind] = append(mx[ind], item)

}

fmt.Println(mx)

https://play.golang.org/p/pHgggHr4nbB