Bagaimana untuk Menggunakan Kaedah Secara Dinamik pada `antara muka{}` dalam Go, Tanpa mengira Jenis Penerima?

Invokasi Dinamik Kaedah pada Antara Muka{} Tanpa mengira Jenis Penerima

Dalam artikel ini, kami meneroka isu yang dihadapi apabila cuba memanggil kaedah secara dinamik pada antara muka{} dalam Go. Matlamat kami adalah untuk mengatasi cabaran ini, membolehkan penggunaan kaedah yang cekap tanpa mengira jenis data asas atau jenis penerima.

Masalahnya

Apabila berurusan dengan antara muka{} dalam Go, kami menghadapi had dalam seruan kaedah dinamik: jika data yang disimpan dalam antara muka{} ialah penunjuk, kami menghadapi kesukaran untuk mengakses alamatnya. Akibatnya, kaedah dengan penerima penunjuk tidak boleh digunakan secara dinamik.

Penyelesaian

Untuk menyelesaikan isu ini, kami memanfaatkan teknik yang merangkumi empat kes:

1. Data antara muka{} ialah nilai, penerima ialah nilai: Dalam kes ini, tiada pengubahsuaian perlu.
2. Data antara muka{} ialah penunjuk, penerima ialah nilai: Kami mencipta penunjuk baharu kepada data{} antara muka dan mendapatkan semula nilai yang dirujuk.
3. Data antara muka{} ialah nilai, penerima ialah penunjuk: Kami mencipta penunjuk baharu kepada antara muka{} data.
4. Data antara muka{} ialah penunjuk, penerima ialah penunjuk: Kami menggunakan penunjuk sedia ada.

Selepas menentukan jenis data yang sesuai, kami lakukan pemeriksaan tambahan untuk kewujudan kaedah pada kedua-dua nilai dan penunjuk. Dengan berbuat demikian, kami memastikan penggunaan kaedah tidak kira sama ada kaedah itu diisytiharkan sebagai nilai atau penerima penunjuk.

Bukti Konsep

Kod berikut menunjukkan pelaksanaan penyelesaian kami:

package main

import (
    "fmt"
    "reflect"
)

type Test struct {
    Start string
}

// value receiver
func (t Test) Finish() string {
    return t.Start + "finish"
}

// pointer receiver
func (t *Test) Another() string {
    return t.Start + "another"
}

func CallMethod(i interface{}, methodName string) interface{} {
    var ptr reflect.Value
    var value reflect.Value
    var finalMethod reflect.Value

    value = reflect.ValueOf(i)

    // if we start with a pointer, we need to get value pointed to
    // if we start with a value, we need to get a pointer to that value
    if value.Type().Kind() == reflect.Ptr {
        ptr = value
        value = ptr.Elem()
    } else {
        ptr = reflect.New(reflect.TypeOf(i))
        temp := ptr.Elem()
        temp.Set(value)
    }

    // check for method on value
    method := value.MethodByName(methodName)
    if method.IsValid() {
        finalMethod = method
    }
    // check for method on pointer
    method = ptr.MethodByName(methodName)
    if method.IsValid() {
        finalMethod = method
    }

    if (finalMethod.IsValid()) {
        return finalMethod.Call([]reflect.Value{})[0].Interface()
    }

    // return or panic, method not found of either type
    return ""
}

func main() {
    i := Test{Start: "start"}
    j := Test{Start: "start2"}

    fmt.Println(CallMethod(i, "Finish"))
    fmt.Println(CallMethod(&i, "Finish"))
    fmt.Println(CallMethod(i, "Another"))
    fmt.Println(CallMethod(&i, "Another"))
    fmt.Println(CallMethod(j, "Finish"))
    fmt.Println(CallMethod(&j, "Finish"))
    fmt.Println(CallMethod(j, "Another"))
    fmt.Println(CallMethod(&j, "Another"))
}

Dengan menggunakan teknik ini, kami boleh menggunakan kaedah secara dinamik pada antara muka{} tanpa mengira jenis penerima, memudahkan dan kod boleh suai dalam Go.

Atas ialah kandungan terperinci Bagaimana untuk Menggunakan Kaedah Secara Dinamik pada `antara muka{}` dalam Go, Tanpa mengira Jenis Penerima?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!