Bagaimanakah Saya Boleh Mengelakkan Pelaksanaan Kaedah Berlebihan untuk Pelbagai Jenis Menggunakan Antara Muka dalam Go?

Melaksanakan Kaedah Biasa untuk Pelbagai Jenis Menggunakan Antara Muka

Dalam Go, antara muka menyediakan mekanisme berkuasa untuk menentukan kontrak yang boleh dilaksanakan oleh pelbagai jenis. Walau bagaimanapun, kadangkala kelihatan berlebihan untuk melaksanakan kaedah yang serupa untuk berbilang jenis yang melaksanakan antara muka yang sama.

Untuk menangani perkara ini, mari kita pertimbangkan contoh dua struktur, Pertama dan Kedua, yang kedua-duanya mengandungi medan rentetan bernama str. Kami mahu kedua-dua struct melaksanakan antara muka A yang mentakrifkan kaedah PrintStr() untuk mencetak nilai str.

Pada mulanya, ia mungkin kelihatan wajar untuk mentakrifkan pelaksanaan berasingan untuk Pertama dan Kedua, seperti berikut:

type First struct {
    str string
}

func (f First) PrintStr() {
    fmt.Print(f.str)
}

type Second struct {
    str string
}

func (s Second) PrintStr() {
    fmt.Print(s.str)
}

Namun, pendekatan ini sememangnya berulang. Untuk mengelakkan lebihan, kita boleh memanfaatkan pendekatan gubahan. Kita boleh mentakrifkan jenis asas WithString yang mengandungi fungsi biasa dan membenamkannya ke dalam kedua-dua struktur Pertama dan Kedua. Ini membolehkan kami mentakrifkan kaedah PrintStr() hanya sekali dalam jenis asas:

type WithString struct {
    str string
}

func (w WithString) PrintStr() {
    fmt.Print(w.str)
}

type First struct {
    WithString
}

type Second struct {
    WithString
}

type A interface {
    PrintStr()
}

Teknik ini secara berkesan memisahkan pelaksanaan kaedah PrintStr() daripada jenis khusus Pertama dan Kedua, menghasilkan lebih banyak asas kod yang ringkas dan boleh diselenggara.

Sebagai contoh, memandangkan penggunaan berikut:

a := First{
    WithString: WithString{
        str: "foo",
    },
}

Memanggil a.PrintStr() akan mencetak "foo" kerana First membenamkan jenis WithString, yang menyediakan pelaksanaan PrintStr().

Dengan menggunakan komposisi dan antara muka, Go membolehkan kami membuat hierarki jenis di mana jenis yang berbeza boleh berkongsi perkara biasa kefungsian tanpa memerlukan kod berlebihan.

Atas ialah kandungan terperinci Bagaimanakah Saya Boleh Mengelakkan Pelaksanaan Kaedah Berlebihan untuk Pelbagai Jenis Menggunakan Antara Muka dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!