可以采用多种类型的功能

Question

I'm trying to create a helper function which will take a map with string keys and return a slice of the map keys.

The problem is that I want the function to not care about the type of the map values.

For example:

stringStringMap := map[string]string{
    "one": "first",
    "two": "second"
}

mapKeys(stringStringMap) // ["one", "two"]

stringIntMap := map[string]int{
    "one": 1,
    "two": 2,
}

mapKeys(strinIntMap) // ["one", "two"]

It seems that the only way around this problem is to create two similar helpers. Something like this:

func mapKeys(m map[string]string) []string {
    ...
}

func mapKeys2(m map[string]int) []string {
    ...
}

But this seems ugly. Is this helper function I'm trying to create possible?If not, is there a good convention I should follow when writing this?

Answer 1

There is a third option not mentioned yet, and that is to use a type switch. This may be a good option if you know that you'll be passing a manageable number of types to the function. It would work like this:

func Keys(m interface{}) ([]string, error) {
    switch t := m.(type) {
    case map[string]string:
        keys := make([]string, 0, len(t))
        for key := range t {
            keys = append(keys, key)
        }
        return keys, nil
    case map[string]int:
        keys := make([]string, 0, len(t))
        for key := range t {
            keys = append(keys, key)
        }
        return keys, nil
    default:
        return nil, fmt.Errorf("unknown map type: %T", m)
    }
}

This still gives you a bunch of seemingly duplicate code, but at least it's all behind a single function name, and it's more efficient than reflection.