Bagaimanakah Go Developers Boleh Mengendalikan Kesatuan dengan Berkesan Tanpa Sokongan Terbina dalam?

Berurusan dengan Kesatuan dalam Go: Penyiasatan Amalan Terbaik

Go tidak mempunyai jenis kesatuan terbina dalam, yang boleh menjadi kelemahan dalam senario tertentu . Sebagai contoh, apabila berurusan dengan penggunaan kesatuan XML, pembangun Go perlu mencari penyelesaian alternatif.

Satu pendekatan biasa ialah mencipta struct kontena untuk menyimpan pelbagai jenis yang boleh membentuk kesatuan. Walau bagaimanapun, pendekatan ini boleh membawa kepada kod kembung dengan fungsi dan kaedah yang berlebihan.

Dalam artikel ini, kami meneroka sama ada terdapat cara yang lebih baik untuk mengendalikan kesatuan dalam Go.

Penyelesaian Semasa : Kod Berlebihan

Pertimbangkan contoh pemodelan lain-lain XML bukan terminal, yang boleh menjadi ulasan, pemprosesan arahan, atau ruang putih. Melaksanakan kod Go untuk kesatuan ini menggunakan struct kontena memerlukan penulisan pembina, pengambil dan predikat untuk setiap jenis:

type Misc struct {
    value interface{}
}

func MiscComment(c *Comment) *Misc { return &Misc{c} }
func MiscProcessingInstruction(pi *ProcessingInstruction) *Misc { return &Misc{pi} }
func MiscWhiteSpace(ws *WhiteSpace) *Misc { return &Misc{ws} }

func (m Misc) IsComment() bool { _, ok := m.value.(*Comment); return ok }
func (m Misc) Comment() *Comment { return m.value.(*Comment) }

Penyelesaian ini adalah verbose dan berulang. Ia tidak mempunyai kesederhanaan dan keanggunan yang sering dikaitkan dengan Go.

Pendekatan Alternatif

Suis Jenis:

Volker mencadangkan jenis suis sebagai alternatif yang berdaya maju:

switch v := m.value.(type) {
    case *Comment: // Type-assert v if needed
    // ...
}

Semasa suis jenis berkurangan kod berulang, ia masih kekurangan keselamatan jenis yang dikuatkuasakan pengkompil.

Penandaan Antara Muka:

Penyelesaian yang berpotensi adalah untuk mencipta antara muka yang mengenal pasti sesuatu sebagai elemen Pelbagai:

type Misc interface {
    ImplementsMisc()
}

type Comment Chars
func (c Comment) ImplementsMisc() {}

type ProcessingInstruction
func (p ProcessingInstruction) ImplementsMisc() {}

Pendekatan ini membolehkan penciptaan fungsi yang hanya mengendalikan objek Pelbagai, membenarkan paksaan jenis di runtime:

func myFunc(m Misc) {
    switch m := m.(type) {
        case Comment: // Type-assert m if needed
        // ...
    }
}

Pertimbangan dan Kesimpulan

Walaupun kekurangan jenis kesatuan terbina dalam dalam Go, pendekatan alternatif ini menyediakan penyelesaian untuk berurusan dengan kesatuan. Walaupun pendekatan struct kontena mereplikasi kesatuan gaya Java, ia memerlukan lebih banyak usaha pengekodan. Pendekatan suis jenis adalah lebih mudah, mengendalikan kesatuan pada masa jalan tetapi dengan keselamatan jenis yang dikurangkan. Akhir sekali, pendekatan antara muka menyediakan kompromi antara keselamatan jenis dan kesederhanaan kod.

Pendekatan mana yang paling sesuai bergantung pada keperluan khusus dan pertukaran yang sanggup diterima oleh pembangun.

Atas ialah kandungan terperinci Bagaimanakah Go Developers Boleh Mengendalikan Kesatuan dengan Berkesan Tanpa Sokongan Terbina dalam?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!