Golang: wskaźnik do funkcji z łańcucha znaków (nazwa funkcji)

Question

Czy jest jakaś szansa na uzyskanie wskaźnika do funkcji z nazwy funkcji, przedstawionego jako ciąg znaków? Wymagało to na przykład wysłania funkcji jako argumentu do innej funkcji. Jakieś metaprogramowanie, wiesz.

Dzięki!

Answer 1

Funkcje Go to wartości pierwszej klasy. Nie musisz powracać do słabych sztuczek z dynamicznych języków.

package main 

import "fmt" 

func someFunction1(a, b int) int { 
     return a + b 
} 

func someFunction2(a, b int) int { 
     return a - b 
} 

func someOtherFunction(a, b int, f func(int, int) int) int { 
     return f(a, b) 
} 

func main() { 
     fmt.Println(someOtherFunction(111, 12, someFunction1)) 
     fmt.Println(someOtherFunction(111, 12, someFunction2)) 
} 

Playground

---

wyjściowa:

123 
99 

Jeżeli wybór funkcji zależy na jakimś okresie czasu tylko znanej wartości, można użyć mapę:

m := map[string]func(int, int) int { 
     "someFunction1": someFunction1, 
     "someFunction2": someFunction2, 
} 

... 

z := someOtherFunction(x, y, m[key]) 

Answer 2

Jestem n całkowicie jasne, co chcesz zrobić. Odpowiedź jnml powinna obejmować podstawy wszystkiego, co próbujesz zrobić.

Chciałbym dodać, że pakiet crypto ma interesujący sposób pośredniego rejestrowania innych pakietów. W szczególności spójrz na crypto.go.

Zasadniczo, jak to działa to pakiet crypto ma pustą mapę takiego:

var regFuncs = make(map[key]func (arg) result) 

Gdzie „klucz” będzie unikatowy typ (int, string, etc ..), a wartość będzie prototyp funkcji, którego się spodziewasz.

Opakowanie to wówczas rejestruje się za pomocą funkcji init:

func init() { 
    master.RegisterFunc("name", myFunc) 
} 

pakiet ten sam być uwzględnione przy użyciu import _ "path/to/package".

A następnie pakiet główny będzie miał sposób na pobranie tej funkcji.

Z crypto, można użyć sha 256 tak:

crypto.SHA256.New() 

Ale trzeba najpierw umieścić go w głównym tak:

import _ "crypto/sha256" 

Mam nadzieję, że to pomaga.

Answer 3

@ Odpowiedź jnml jest prawdopodobnie tym, co powinieneś zrobić.

Oto podejście z wykorzystaniem refleksji, która pozwala również przekazywać elastyczną liczbę argumentów. obecnie konieczne jest ręczne utworzenie listy obsługiwanych funkcji (mapy) (patrz metoda główna), ale może to zostać poprawione przez kogoś.

package main 

import "fmt" 
import "reflect" 
import "errors" 

func foo() { 
    fmt.Println("we are running foo") 
} 

func bar(a, b, c int) { 
    fmt.Println("we are running bar", a, b, c) 
} 

func Call(m map[string]interface{}, name string, params ... interface{}) (result []reflect.Value, err error) { 
    f := reflect.ValueOf(m[name]) 
    if len(params) != f.Type().NumIn() { 
     err = errors.New("The number of params is not adapted.") 
     return 
    } 
    in := make([]reflect.Value, len(params)) 
    for k, param := range params { 
     in[k] = reflect.ValueOf(param) 
    } 
    result = f.Call(in) 
    return 
} 

func main() { 
    // nota bene: for perfect score: use reflection to build this map 
    funcs := map[string]interface{} { 
      "foo": foo, 
      "bar": bar, 
    } 

    Call(funcs, "foo") 
    Call(funcs, "bar", 1, 2, 3) 
} 

inspiracji/źródło: http://www.mikespook.com/2012/07/function-call-by-name-in-golang/

Answer 4

Jeśli funkcja jest 'metoda', można użyć reflect.Value.MethodByName

zobaczyć reflect documentation here