Bagaimanakah saya boleh mencapai kebolehlanjutan seperti warisan dalam Go tanpa menggunakan warisan tradisional?

Golang dan Warisan: Pendekatan Alternatif untuk Diperluaskan

Gambaran Keseluruhan Masalah:

Matlamat: Untuk mencipta struct asas dengan boleh diguna semula kaedah yang boleh dilanjutkan oleh struct lain. Walau bagaimanapun, struktur Go mengehadkan akses kepada kaedah struct induk, menjadikan warisan tradisional mustahil.

Corak Asal:

Pengguna mencadangkan corak berbelit-belit yang melibatkan tingkah laku seperti warisan :

type MyInterface interface {
  SomeMethod(string)
  OtherMethod(string)
}

type Base struct{
  B MyInterface
}

func (b *Base) SomeMethod(x string) {
  b.B.OtherMethod(x)
}

type Extender struct {
  Base
}

func (b *Extender) OtherMethod(x string) {
  // Do something...
}

func NewExtender() *Extender { 
  e := Extender{}
  e.Base.B = &e
  return &e
}

Pendekatan Go: Komposisi berbanding Warisan

Go menggalakkan komposisi berbanding warisan untuk fleksibiliti dan kebolehselenggaraan. Daripada subkelas, Go menggalakkan penggunaan antara muka dan membenamkan struct untuk mencapai kebolehlanjutan.

Membenamkan:

Membenamkan membenarkan struct memasukkan secara langsung medan dan kaedah struct lain, dengan berkesan menggunakan semula fungsinya. Sebagai contoh, jika kita mempunyai antara muka Pembaca dan Penulis, kita boleh mencipta antara muka ReadWriter gabungan dan membenamkan pelaksanaan Pembaca dan Penulis:

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

type ReadWriter interface {
    Reader
    Writer
}

type MyReadWriter struct {
    *MyReader
    *MyWriter

    // Additional ReadWriter-specific methods if needed
}

Struktur MyReadWriter kini boleh mengakses dan menggunakan semua kaedah daripada kedua-dua MyReader dan MyWriter, melaksanakan antara muka ReadWriter dengan lancar.

Kebergantungan Suntikan:

Pembenaman juga memudahkan suntikan pergantungan, yang membolehkan ujian dan penyahgandingan yang lebih baik. MyReader dan MyWriter boleh disuntik ke dalam struct MyReadWriter, memastikan bahawa kebergantungan diluluskan secara eksplisit, meningkatkan kebolehujian.

Contoh Penggunaan:

func (rw *MyReadWriter) DoCrazyStuff() {
    data := []byte{}
    // Do stuff...
    rw.Read(data)
    rw.Write(data)
    // You get the idea...
}

func main() {
    rw := &MyReadWriter{&MyReader{}, &MyWriter{}}
    rw.DoCrazyStuff()
}

Dalam ini contoh, struktur rw boleh bertindak sebagai Pembaca dan Penulis, membolehkan untuk serba boleh penggunaan dalam pelbagai senario.

Atas ialah kandungan terperinci Bagaimanakah saya boleh mencapai kebolehlanjutan seperti warisan dalam Go tanpa menggunakan warisan tradisional?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!