Bagaimanakah saya boleh menggunakan semula kod apabila melaksanakan kaedah biasa untuk jenis yang berbeza dalam Go?

Melaksanakan Kaedah Biasa dengan Antara Muka dalam Go

Dalam Go, antara muka menyediakan mekanisme untuk jenis yang berbeza untuk melaksanakan set kaedah yang sama, membenarkan untuk polimorfisme dalam kod anda. Walau bagaimanapun, kadangkala anda mungkin menghadapi situasi di mana anda mahu dua jenis berbeza melaksanakan kaedah biasa tetapi elakkan kod berlebihan.

Pertimbangkan senario berikut:

type First struct {
    str string
}

type Second struct {
    str string
}

type A interface {
    PrintStr()
}

Untuk melaksanakan kaedah PrintStr untuk kedua-dua struct Pertama dan Kedua, anda biasanya akan menulis kaedah berasingan berikut:

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

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

Walaupun pendekatan ini berfungsi, ia boleh membawa kepada pertindihan kod jika anda mempunyai berbilang jenis yang perlu melaksanakan kaedah yang sama. Untuk mengatasinya, Go menawarkan penyelesaian elegan yang dikenali sebagai pembenaman jenis.

Pembenaman Jenis

Pembenaman jenis membolehkan anda mengarang jenis baharu dengan membenamkan jenis sedia ada ke dalamnya. Dalam kes ini, kita boleh mencipta jenis asas yang mengandungi medan str biasa dan kaedah PrintStr.

type WithString struct {
    str string
}

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

Kini, kita boleh membenamkan jenis WithString ke dalam struct Pertama dan Kedua kami:

type First struct {
    WithString
}

type Second struct {
    WithString
}

Dengan berbuat demikian, kedua-dua struktur Pertama dan Kedua mewarisi kaedah PrintStr daripada jenis WithString terbenam. Ini menghapuskan keperluan untuk pelaksanaan kaedah berasingan untuk setiap struct.

Contoh

Berikut ialah contoh cara menggunakan pembenaman jenis untuk melaksanakan kaedah biasa untuk dua jenis berbeza:

package main

import "fmt"

type WithString struct {
    str string
}

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

type First struct {
    WithString
}

type Second struct {
    WithString
}

func main() {
    a := First{
        WithString: WithString{
            str: "foo",
        },
    }

    a.PrintStr() // Outputs: foo
}

Pendekatan ini membolehkan anda mengekalkan satu pelaksanaan untuk kaedah biasa sambil membolehkannya digunakan oleh jenis yang berbeza, menggalakkan kebolehgunaan semula kod dan mengurangkan pertindihan kod.

Atas ialah kandungan terperinci Bagaimanakah saya boleh menggunakan semula kod apabila melaksanakan kaedah biasa untuk jenis yang berbeza dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!