Dictionary 带有回调的映射到具有接收器的函数的语法

是否可以在golang中创建包含具有接收器的函数的地图

我想完成以下几点

函数回调：

func (my *mystruct) doSometing(int parameter1){
// do something
}

func (my *mystruct) doAnotherThing(int parameter1){
// do something
}

包含函数指针的映射

var lookupMap = map[string]func(int){
    "action1" : doSomething,
    "action2" : doAnotherThing
}

不幸的是，这不起作用，因为回调函数绑定到接收器。Go编译器说：

"undefined doSomething"

我的问题：

func (my *mystruct) doSometing(int parameter1){
// do something
}

func (my *mystruct) doAnotherThing(int parameter1){
// do something
}

当值是绑定到特定接收器的函数时，创建映射的语法是什么

类似于（伪代码）：

感谢您的帮助

使用方法值 您可以为此目的使用。方法值是具有隐式接收器的函数值。引述自：

如果表达式

x

具有静态类型

T

且

M

在类型

T

的方法集中，则

x.M

称为方法值

因此，方法值的语法是

x.M

，例如

x

是类型的值，

M

是方法的名称。这将导致函数的参数（和返回类型）与没有接收器的方法相同，因为接收器将与方法值一起保存，并且是隐式的

因此，这意味着要为

doSometing（）

和

doAnotherThing（）

方法存储方法值，函数类型将只是

func（int）

（无接收器）

下面是一个工作示例：

type mystruct struct {
    name string
}

func (my *mystruct) doA(i int) {
    fmt.Printf("[doA]: I'm %s, param is: %d\n", my.name, i)
}

func (my *mystruct) doB(i int) {
    fmt.Printf("[doB]: I'm %s, param is: %d\n", my.name, i)
}

func main() {
    my1 := &mystruct{"Bob"}
    my2 := &mystruct{"Alice"}
    lookupMap := map[string]func(int){
        "action1": my1.doA,
        "action2": my2.doB,
    }

    lookupMap["action1"](11)
    lookupMap["action2"](22)
}

输出（在上尝试）：

使用方法表达式 如果不想将接收器保存在字典中（在方法值中），可以使用

不同之处在于，当您获取函数值时，您不使用

x.M

，而是使用

t.M

，这将产生函数值，函数类型具有相同的参数（和返回类型），但接收器类型也将首先出现在参数列表中。见引自：

如果

M

在类型为

T

的方法集中，

T.M

是一个可作为常规函数调用的函数，其参数与

M

相同，前缀是作为方法接收者的附加参数

因此，在您的示例中，要使用的函数类型如下：

func（*mystruct，int）

此外，由于不会保存接收器，因此在调用这些函数时必须提供它

请参阅此工作示例（对第一个示例的修改）：

输出相同（请在上尝试）：

---

见类似问题：

---

与方法值类似，这也可以通过闭包范围实现

package main

import (
    "fmt"
)

type mystruct struct {
    name string
}

func addCallbackToMap(lookupMap map[string]func(int), key string, my *mystruct) {
    lookupMap[key] = func(i int) {
        fmt.Printf("I'm %s, param is: %d\n", my.name, i)
    }
}

func main() {
    my1 := &mystruct{"Bob"}
    my2 := &mystruct{"Alice"}

    lookupMap := map[string]func(int){}
    addCallbackToMap(lookupMap, "action1", my1)
    addCallbackToMap(lookupMap, "action2", my2)

    lookupMap["action1"](11)
    lookupMap["action2"](22)
}

输出（在上尝试）：

---

这是可能的。请参阅可能的副本：1；2.伟大的谢谢你的全面回答！方法表达式完成了这项工作

type mystruct struct {
    name string
}

func (my *mystruct) doA(i int) {
    fmt.Printf("[doA]: I'm %s, param is: %d\n", my.name, i)
}

func (my *mystruct) doB(i int) {
    fmt.Printf("[doB]: I'm %s, param is: %d\n", my.name, i)
}

func main() {
    lookupMap := map[string]func(*mystruct, int){
        "action1": (*mystruct).doA,
        "action2": (*mystruct).doB,
    }

    my1 := &mystruct{"Bob"}
    my2 := &mystruct{"Alice"}
    lookupMap["action1"](my1, 11)
    lookupMap["action2"](my2, 22)
}

[doA]: I'm Bob, param is: 11
[doB]: I'm Alice, param is: 22

package main

import (
    "fmt"
)

type mystruct struct {
    name string
}

func addCallbackToMap(lookupMap map[string]func(int), key string, my *mystruct) {
    lookupMap[key] = func(i int) {
        fmt.Printf("I'm %s, param is: %d\n", my.name, i)
    }
}

func main() {
    my1 := &mystruct{"Bob"}
    my2 := &mystruct{"Alice"}

    lookupMap := map[string]func(int){}
    addCallbackToMap(lookupMap, "action1", my1)
    addCallbackToMap(lookupMap, "action2", my2)

    lookupMap["action1"](11)
    lookupMap["action2"](22)
}

I'm Bob, param is: 11
I'm Alice, param is: 22