kaedah sambungan golang

Golang ialah bahasa pengaturcaraan yang telah muncul sejak beberapa tahun kebelakangan ini Disebabkan oleh pemprosesan concurrency yang cekap dan sintaks yang ringkas, semakin ramai pembangun telah mula menggunakan Golang. Walau bagaimanapun, Golang tidak mempunyai beberapa ciri biasa dalam pengaturcaraan berorientasikan objek (OOP), seperti kaedah sambungan. Dalam artikel ini, kami akan memperkenalkan cara melaksanakan kaedah sambungan di Golang.

Apakah kaedah sambungan

Dalam OOP, kelas biasanya mengandungi beberapa kaedah yang hanya boleh dipanggil oleh objek contoh kelas. Walau bagaimanapun, kadangkala kita perlu menambah beberapa kaedah baharu pada kelas tanpa mengubah suai kod sumber Ini adalah apabila kaedah sambungan berguna. Kaedah sambungan ialah teknologi yang memanjangkan jenis sedia ada Ia membolehkan kita menambah kaedah baharu kepada jenis sedia ada tanpa mewarisi atau mengubah suai kod sumber. Pelaksanaan kaedah sambungan boleh berada di mana-mana, walaupun dalam fail kod yang berbeza.

Cara melaksanakan kaedah sambungan dalam Golang

Golang ialah bahasa pengaturcaraan ditaip secara statik, yang tidak mempunyai beberapa ciri dalam pengaturcaraan berorientasikan objek, seperti warisan, polimorfisme, dsb. Walau bagaimanapun, Golang menyediakan beberapa ciri lain, seperti antara muka, struktur tanpa nama, dsb., yang boleh digunakan untuk melaksanakan kaedah sambungan.

Kaedah Antara Muka

Di Golang, kita boleh menentukan jenis antara muka dan menggunakannya sebagai pengganti untuk jenis yang melaksanakan kaedah tertentu. Jika sesuatu jenis melaksanakan semua kaedah yang ditakrifkan dalam antara muka, ia boleh dianggap sebagai pelaksanaan antara muka. Di sini, kita boleh mentakrifkan jenis antara muka dan kemudian mentakrifkan kaedah yang ingin kita panjangkan dalam antara muka.

Sebagai contoh, kami mentakrifkan antara muka bernama Ints dan kemudian mentakrifkan beberapa kaedah untuknya:

type Ints interface {
    Find(i int) bool
    Reverse()
}

Seterusnya kita boleh menentukan jenis yang perlu dilanjutkan dan mengisytiharkan bahawa ia melaksanakan Ints antara muka. Sebagai contoh, kami mentakrifkan jenis yang dipanggil IntList yang boleh mengandungi set integer dan melaksanakan antara muka Ints:

type IntList []int

func (list IntList) Find(i int) bool {
    for _, n := range list {
        if n == i {
            return true
        }
    }
    return false
}

func (list IntList) Reverse() {
    for i, j := 0, len(list)-1; i < j; i, j = i+1, j-1 {
        list[i], list[j] = list[j], list[i]
    }
}

Sekarang, kita boleh memanggil IntList menggunakan contoh jenis Find dan Kaedah Reverse, seperti yang ditunjukkan di bawah:

func main() {
    list := IntList{5, 3, 2, 8, 6}
    fmt.Println(list.Find(8)) // true
    list.Reverse()
    fmt.Println(list) // [6 8 2 3 5]
}

Kaedah struktur tanpa nama

Selain kaedah antara muka, kami juga boleh menggunakan kaedah struktur tanpa nama untuk melaksanakan kaedah sambungan. Di Golang, kita boleh mencipta struktur tanpa nama dan menentukan kaedah sambungan pada struktur. Kelebihan kaedah ini ialah kita boleh melanjutkan kaedah baharu untuk jenis sedia ada tanpa mengubah suai kod sumbernya.

Sebagai contoh, kami mentakrifkan jenis IntList, kemudian mentakrifkan struktur tanpa nama dan menggunakan IntList sebagai medan struktur. Seterusnya, kita boleh menentukan kaedah yang ingin kita panjangkan pada struktur tanpa nama.

type IntList []int

func (list IntList) Iterate(f func(int)) {
    for _, n := range list {
        f(n)
    }
}

type ListProcessor struct {
    IntList
}

func (p *ListProcessor) Sum() int {
    sum := 0
    p.Iterate(func(n int) {
        sum += n
    })
    return sum
}

Dalam contoh di atas, kami melanjutkan kaedah bernama Iterate yang menerima fungsi untuk bekerja dengan integer. Kami juga mentakrifkan struktur tanpa nama bernama ListProcessor, yang mengandungi medan jenis IntList dan mentakrifkan kaedah bernama Sum padanya.

Kini, kita boleh memanggil kaedah ListProcessor pada contoh Sum seperti berikut:

func main() {
    list := IntList{1, 2, 3, 4, 5}
    p := &ListProcessor{list}
    sum := p.Sum()
    fmt.Println(sum)
}

Ringkasan

Golang tidak menyokong OOP seperti ciri penting warisan atau polimorfisme , yang menjadikan pelaksanaan kaedah sambungan lebih sukar. Walau bagaimanapun, di Golang, kita boleh menggunakan kaedah antara muka dan kaedah struct tanpa nama untuk melaksanakan kaedah sambungan. Kaedah ini membantu menambah kaedah baharu pada jenis sedia ada tanpa mengubah suai kod sumber. Kaedah yang anda pilih bergantung pada keperluan anda.

Atas ialah kandungan terperinci kaedah sambungan golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!