可以采用多种类型的函数

Question

我正在尝试创建一个辅助函数，它将获取带有字符串键的映射并返回映射键的一部分。

问题是我希望函数不关心地图值的类型。

例如：

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

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

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

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

似乎解决这个问题的唯一方法是创建两个类似的助手。像这样的：

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

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

但这看起来很难看。我正在尝试创建的这个辅助函数是否可行？如果不是，在编写此代码时我应该遵循一个好的约定吗？

Answer 1

解决此问题的一种方法是在创建地图时使用“interface{}”，然后在方法中使用type switch 语句，即

func mapKeys(m map[string]interface{}) []string {
    for k,v := range m {
        switch a := v.(type) {
        case int:
          ... do int stuff
        case string:
          ... do string stuff
        }
    }
}

Answer 2

Go 没有用户指定的通用参数类型，因此您所描述的必须通过以下方式完成：

1. 接受您希望支持的不同类型的单独函数，或
2. 接受空接口 (interface{}) 并使用 reflection 的函数。

这是第二种方法的示例实现：

package main

import (
    "fmt"
    "reflect"
)

func main() {
    stringStringMap := map[string]string{
        "one": "first",
        "two": "second",
    }

    fmt.Println(mapKeys(stringStringMap)) // ["one", "two"]

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

    fmt.Println(mapKeys(stringIntMap)) // ["one", "two"]
}

func mapKeys(m interface{}) []string {
    v := reflect.ValueOf(m)
    if v.Kind() != reflect.Map {
        panic("m is not a map")
    }
    if v.Type().Key().Kind() != reflect.String {
        panic("m does not have a string key")
    }
    keys := make([]string, 0, v.Len())
    for _, key := range v.MapKeys() {
        keys = append(keys, key.String())
    }
    return keys
}

Answer 3

还有第三个选项还没有提到，那就是使用类型开关。如果您知道将可管理数量的类型传递给函数，这可能是一个不错的选择。它会像这样工作：

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)
    }
}

这仍然会给你一堆看似重复的代码，但至少它们都在一个函数名后面，而且比反射更有效。