Go map of functions

Question

I have Go program that has a function defined. I also have a map that should have a key for each function. How can I do that?

I have tried this, but this doesn't work.

func a(param string) {

}

m := map[string] func {
    'a_func': a,
}

for key, value := range m {
   if key == 'a_func' {
    value(param) 
   }
}

peterSO · Accepted Answer · 2011-07-21T02:21:12.163

85

Are you trying to do something like this? I've revised the example to use varying types and numbers of function parameters.

package main

import "fmt"

func f(p string) {
    fmt.Println("function f parameter:", p)
}

func g(p string, q int) {
    fmt.Println("function g parameters:", p, q)
}

func main() {
    m := map[string]interface{}{
        "f": f,
        "g": g,
    }
    for k, v := range m {
        switch k {
        case "f":
            v.(func(string))("astring")
        case "g":
            v.(func(string, int))("astring", 42)
        }
    }
}

edited Jul 21 '11 at 02:21

answered Jul 21 '11 at 01:17

peterSO

158,998
31
281
276

that's almost exactly what I need, but let's say g needed 2 string parameters. Is that possible? – Conceited Code Jul 21 '11 at 02:00
Could you elaborate on "v.(func(string))"; that seems like it would almost need the reflect package. Do the parens here do any casting, or is it all dealing with the basic interface? – Docunext Feb 12 '13 at 23:54
And instead of using f and g as the map values, could you instead have string values there, and instead call f(mapValue) under case "f":? – Docunext Feb 13 '13 at 00:00
what if your functions are from a struct type? – Chuque May 23 '21 at 06:17

Seth Hoenig · Answer 2 · 2013-02-15T16:06:19.637

80

m := map[string]func(string, string)

Works if you know the signature (and all the funcs have the same signature) I think this is cleaner/safer than using interface{}

edited Feb 15 '13 at 16:06

answered Jul 22 '11 at 23:35

Seth Hoenig

7,047
6
31
30

1

All the functions don't have the same signature. – peterSO Jul 23 '11 at 00:42
Actually I think this answers my above question; my functions have the same signature. But... here I see the map value is a function with arguments. Interesting, I'll try that as well as passing just the arguments to compare. – Docunext Feb 13 '13 at 00:02
8

Also, say the function returns a string variable, it would look like this: `m := map[string]func(string, string)string` – GreenRaccoon23 Apr 25 '15 at 18:26

score 24 · Answer 3 · answered Mar 19 '13 at 18:05

You can define a type if functions are same interface.

package main

import "log"

type fn func (string)

func foo(msg string) {
  log.Printf("foo! Message is %s", msg)
}

func bar(msg string) {
  log.Printf("bar! Message is %s", msg)
}

func main() {
  m := map[string] fn {
    "f": foo,
    "b": bar,
  }
  log.Printf("map is %v", m)
  m["f"]("Hello")
  m["b"]("World")
}

tleb · Answer 4 · 2016-08-21T12:15:31.937

16

@Seth Hoenig's answer helped me best, but I just wanted to add that Go accepts functions with defined return value as well:

package main

func main() {
    m := map[string]func(string) string{
        "foo": func(s string) string { return s + "nurf" },
    }

    m["foo"]("baz") // "baznurf"
}

If you think it's ugly, you could always use a type (see @smagch's answer).

edited Aug 21 '16 at 12:15

answered Aug 21 '16 at 10:28

tleb

4,395
3
25
33

How to use a type: https://play.golang.org/p/CtVoOzkT3hw. Good example +1. – Sep 12 '20 at 06:56

score 2 · Answer 5 · answered May 28 '20 at 23:22

I used a map[string]func (a type, b *type) I passed a string to search the map and a pointer to modify the slice.

Hope that helps!

var Exceptions map[string]func(step string, item *structs.Item)

func SetExceptions() {
    Exceptions = map[string]func(a string, i *structs.Item){
        "step1": step1,
    }
}

func RunExceptions(state string, item *structs.Item) {
    method, methBool := Exceptions[state]
    if methBool {
        method(state, item)
    }
}

func step1(step string, item *structs.Item) {
    item.Title = "Modified"
}

score 2 · Answer 6 · answered Sep 09 '22 at 10:36

Hope this works for you(you can use interface{} instead any)

package main

import (

    "fmt"

)


func toon(v any) {

    fmt.Println(v)

}

func main() {

    names := map[string]any{

        "Function": toon,

    }

    names["Function"].(func(any))("a")

}

score 1 · Answer 7 · answered Apr 16 '20 at 09:37

Here is the way I made it work in my case:

package main

import (
    "fmt"
)

var routes map[string]func() string

func main() {
    routes = map[string]func() string{
        "GET /":      homePage,
        "GET /about": aboutPage,
    }

    fmt.Println("GET /", pageContent("GET /"))
    fmt.Println("GET /about", pageContent("GET /about"))
    fmt.Println("GET /unknown", pageContent("GET /unknown"))
    // Output:
    // GET / Home page
    // GET /about About page
    // GET /unknown 404: Page Not Found
}

func pageContent(route string) string {
    page, ok := routes[route]
    if ok {
        return page()
    } else {
        return notFoundPage()
    }
}

func homePage() string {
    return "Home page"
}

func aboutPage() string {
    return "About page"
}

func notFoundPage() string {
    return "404: Page Not Found"
}

https://play.golang.org/p/8_g6Di1OKZS

Go map of functions

7 Answers7

Linked

Related