How to use function as map's key

huangapple
go评论130阅读模式
英文:

How to use function as map's key

问题

如何将函数用作map的键？例如：

  1. type Action func(int)
  2. func test(a int) { }
  3. func test2(a int) { }
  5. func main() {
  6.   x := map[Action]bool{}
  7.   x[test] = true
  8.   x[test2] = false
  9. }

这段代码会显示一个错误：invalid map key type Action。

要将函数用作map的键，需要满足以下条件：

  1. 函数类型必须是可比较的类型，即函数类型必须支持相等性比较。
  2. 函数类型的参数和返回值类型必须是可比较的类型。

在上面的示例中，Action类型是一个函数类型，它的参数类型是int，返回值类型是空。由于空返回值类型不是可比较的类型，所以无法将Action类型用作map的键。要解决这个问题，可以修改Action类型的返回值类型为可比较的类型，或者考虑其他的键类型来代替函数类型。

英文:

How to use function as map's key? for example:

  1. type Action func(int)
  2. func test(a int) { }
  3. func test2(a int) { }
  5. func main() {
  6.   x := map[Action]bool{}
  7.   x[test] = true
  8.   x[test2] = false
  9. }

those code would show an error: invalid map key type Action

答案1

得分: 13

你不能将函数用作映射键。语言规范明确指出：

> 对于键类型的操作数，比较运算符==和!=必须完全定义；因此，键类型不能是函数、映射或切片。

英文:

You cannot use a function as a map key. The language specification clearly says:

> The comparison operators == and != must be fully defined for operands of the key type; thus the key type must not be a function, map, or slice.

答案2

得分: 7

你不能在映射中使用函数作为键：键的类型必须是可比较的。

根据Go博客：

映射的键可以是任何可比较的类型。语言规范对此有明确的定义，但简而言之，可比较的类型包括布尔、数值、字符串、指针、通道和接口类型，以及仅包含这些类型的结构体或数组。需要注意的是，切片、映射和函数不在此列表中；这些类型不能使用==进行比较，也不能用作映射的键。

根据你具体的用例，你可能会使用接口。

英文:

You can't use functions as keys in maps : the key type must be comparable.

From Go blog :

> map keys may be of any type that is comparable. The language spec
> defines this precisely, but in short, comparable types are boolean,
> numeric, string, pointer, channel, and interface types, and structs or
> arrays that contain only those types. Notably absent from the list are
> slices, maps, and functions; these types cannot be compared using ==,
> and may not be used as map key

What you might use, depending on your precise use case, is an interface.

答案3

得分: 7

你可以使用reflect。

  1. import (
  2.    "reflect"
  3.    "math"
  4. )
  7. func foo() {
  8.    table := make(map[uintptr]string)
  9.    table[reflect.ValueOf(math.Sin)] = "Sin"
  10.    table[reflect.ValueOf(math.Cos)] = "Cos"
  11.    println(table[reflect.ValueOf(math.Cos)])
  12. }
英文:

You can use reflect.

  1.     import (
  2.        "reflect"
  3.        "math"
  4.     )
  5.      
  7.     func foo () {
  8.        table := make(map[uintptr] string)
  9.        table[reflect.ValueOf(math.Sin)] = "Sin"
  10.        table[reflect.ValueOf(math.Cos)] = "Cos"
  11.        println(table[reflect.ValueOf(math.Cos)])
  12.     }

答案4

得分: 6

虽然函数不能作为键，但函数指针可以。

  1. package main
  3. import "fmt"
  5. type strFunc *func() string
  7. func main() {
  8.     myFunc := func() string { return "bar" }
  9.     m := make(map[strFunc]string)
  10.     m[(strFunc)(&myFunc)] = "f"
  12.     for f, name := range m {
  13.         fmt.Println((*f)(), name)
  14.     }
  15. }

点击此处查看代码。

英文:

While functions can't be keys, function pointers can.

  1. package main
  3. import "fmt"
  5. type strFunc *func() string
  7. func main() {
  9.     myFunc := func() string { return "bar" }
  10.     m := make(map[strFunc]string)
  11.     m[(strFunc)(&myFunc)] = "f"
  13.     for f, name := range m {
  14. 	    fmt.Println((*f)(), name)
  15.     }
  16. }

http://play.golang.org/p/9DdhYduX7E

答案5

得分: 4

函数不能作为键：
> 比较运算符 == 和 != 必须对键类型的操作数进行完全定义；因此，键类型不能是函数、映射或切片。

来源

英文:

Functions cannot be keys:
> The comparison operators == and != must be fully defined for operands of the key type; thus the key type must not be a function, map, or slice.

Source

答案6

得分: 3

你不能直接这样做，如前所述，但你可以通过以下方式来模拟实现：

  1. package main
  3. import "fmt"
  5. func a(i int) int {
  6. 	return i + 1
  7. }
  9. func b(i int) int {
  10. 	return i + 2
  11. }
  13. type Function func(int) int
  14. type FunctionWrapper struct {
  15. 	f *Function
  16. }
  18. var fnMap = make(map[string]FunctionWrapper)
  20. // MakeFunctionWrapper 根据函数指针返回唯一的 FunctionWrapper，使用 fnMap 避免为相同函数有多个值
  21. func MakeFunctionWrapper(f Function) FunctionWrapper {
  22. 	key := fmt.Sprintf("%#v", f)
  23. 	data, ok := fnMap[key]
  24. 	if !ok {
  25. 		data = FunctionWrapper{&f}
  26. 		fnMap[key] = data
  27. 	}
  28. 	return data
  29. }
  31. func main() {
  32. 	functions := make(map[FunctionWrapper]bool)
  33. 	fa := MakeFunctionWrapper(a)
  34. 	fb := MakeFunctionWrapper(b)
  35. 	fb2 := MakeFunctionWrapper(b)
  36. 	functions[fa] = true
  37. 	functions[fb] = true
  38. 	functions[fb2] = false // 这会覆盖之前的值，因为 fb 本质上与 fb2 相同
  40. 	fmt.Println(functions[fa])  // "true"
  41. 	fmt.Println(functions[fb])  // "false"
  42. 	fmt.Println(functions[fb2]) // "false"
  43. }

这种方法有点繁琐，而且我认为将指针的字符串版本用作映射的键是一个非常糟糕的主意。但是...如果你真的需要的话，至少这是一个选项。

英文:

You cannot do this directly, as mentioned already, but you can sort of fake it you do something like this:

  1. package main
  3. import "fmt"
  5. func a(i int) int {
  6. 	return i + 1
  7. }
  9. func b(i int) int {
  10. 	return i + 2
  11. }
  13. type Function func(int)int
  14. type FunctionWrapper struct {
  15. 	f *Function
  16. }
  18. var fnMap = make(map[string]FunctionWrapper)
  20. // MakeFunctionWrapper returns a unique FunctionWrapper per Function pointer, using fnMap to avoid having multiple values for the same function
  21. func MakeFunctionWrapper(f Function) FunctionWrapper {
  22. 	key := fmt.Sprintf("%#v", f)
  23. 	data, ok := fnMap[key]
  24. 	if !ok {
  25. 		data = FunctionWrapper{&f}
  26. 		fnMap[key] = data
  27. 	}
  28. 	return data
  29. }
  31. func main() {
  32. 	functions := make(map[FunctionWrapper]bool)
  33. 	fa := MakeFunctionWrapper(a)
  34. 	fb := MakeFunctionWrapper(b)
  35. 	fb2 := MakeFunctionWrapper(b)
  36. 	functions[fa] = true
  37. 	functions[fb] = true
  38. 	functions[fb2] = false				// This overwrites the previous value since fb is essentially the same as fb2
  40. 	fmt.Println(functions[fa])			// "true"
  41. 	fmt.Println(functions[fb])			// "false"
  42. 	fmt.Println(functions[fb2])			// "false"
  43. }

Check it out on the Go playground

This is a bit cumbersome, and I honestly think it's a very bad idea to essentially use the string version of a pointer as your map's key. But ... it's at least an option if you really need it.

答案7

得分: 2

一种简洁的方法是将函数包装在一个struct中，然后使用该结构的指针作为映射的键：

  1. type FuncPack struct {
  2.     TheFunc func(a int)
  3. }
  5. func Test(a int)  {}
  6. func Test2(a int) {}
  8. func main() {
  9.     theMap := make(map[*FuncPack]bool)
  10.     theMap[&FuncPack{TheFunc: Test}] = true
  11.     theMap[&FuncPack{TheFunc: Test2}] = false
  12. }

这样做可以实现你的需求。

英文:

A clean way to achieve this is to wrap the functions in a struct, then use a pointer to this struct as the map key:

  1. type FuncPack struct {
  2.     TheFunc func(a int)
  3. }
  5. func Test(a int)  {}
  6. func Test2(a int) {}
  8. func main() {
  9.     theMap := make(map[*FuncPack]bool)
  10.     theMap[&FuncPack{TheFunc: Test}] = true
  11.     theMap[&FuncPack{TheFunc: Test2}] = false
  12. }

答案8

得分: 1

使用函数指针作为映射键，而不是函数。

以下示例将函数的依赖关系存储在映射中，计算执行顺序并按正确顺序执行函数：

  1. package main
  3. import (
  4. 	"fmt"
  5. )
  7. type Action func()
  9. var Premises = make(map[*Action][]*Action)
  11. func OnSetup(action Action, premises ...*Action) *Action {
  12. 	ap := &action
  13. 	Premises[ap] = premises
  14. 	return ap
  15. }
  17. func rank(action *Action) int {
  18. 	if len(Premises[action]) == 0 {
  19. 		return 0
  20. 	}
  21. 	max := 0
  22. 	for _, p := range Premises[action] {
  23. 		r := rank(p)
  24. 		if r > max {
  25. 			max = r
  26. 		}
  27. 	}
  28. 	return max + 1
  29. }
  31. func Setup() {
  32. 	ranks := make(map[int][]*Action)
  33. 	for action := range Premises {
  34. 		r := rank(action)
  35. 		ranks[r] = append(ranks[r], action)
  36. 	}
  37. 	for r := 0; r < len(ranks); r++ {
  38. 		fmt.Println("Rank:", r)
  39. 		actions := ranks[r]
  40. 		for a := range actions {
  41. 			(*(actions[a]))()
  42. 		}
  43. 	}
  44. }
  46. func main() {
  47. 	a := OnSetup(func() { fmt.Println("a") })
  48. 	b := OnSetup(func() { fmt.Println("b") }, a)
  49. 	OnSetup(func() { fmt.Println("c") }, b)
  50. 	OnSetup(func() { fmt.Println("d") })
  51. 	Setup()
  52. }

希望对你有帮助！

英文:

Use function pointers as map keys instead of functions.

The following example stores dependencies of function in a map, calculates the execution order and executes the functions in the correct order:

  1. package main
  2. import (
  3. &quot;fmt&quot;
  4. )
  5. type Action func()
  6. var Premises = make(map[*Action][]*Action)
  7. func OnSetup(action Action, premises ...*Action) *Action {
  8. ap := &amp;action
  9. Premises[ap] = premises
  10. return ap
  11. }
  12. func rank(action *Action) int {
  13. if len(Premises[action]) == 0 {
  14. return 0
  15. }
  16. max := 0
  17. for _, p := range Premises[action] {
  18. r := rank(p)
  19. if r &gt; max {
  20. max = r
  21. }
  22. }
  23. return max + 1
  24. }
  25. func Setup() {
  26. ranks := make(map[int][]*Action)
  27. for action := range Premises {
  28. r := rank(action)
  29. ranks[r] = append(ranks[r], action)
  30. }
  31. for r := 0; r &lt; len(ranks); r++ {
  32. fmt.Println(&quot;Rank:&quot;, r)
  33. actions := ranks[r]
  34. for a := range actions {
  35. (*(actions[a]))()
  36. }
  37. }
  38. }
  39. func main() {
  40. a := OnSetup(func() { fmt.Println(&quot;a&quot;) })
  41. b := OnSetup(func() { fmt.Println(&quot;b&quot;) }, a)
  42. OnSetup(func() { fmt.Println(&quot;c&quot;) }, b)
  43. OnSetup(func() { fmt.Println(&quot;d&quot;) })
  44. Setup()
  45. }

huangapple
  • 本文由 发表于 2014年12月3日 16:38:47
  • 转载请务必保留本文链接：https://go.coder-hub.com/27267042.html
  • dictionary
  • function
  • go
  • key
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定