将接口转换为具体类型 - 类型开关

Question

我正在寻找一种将接口转换为具体类型以节省大量源代码的方法。

初始情况是网络服务器处理程序的两个功能。 它们的区别仅在于一个 function 解码一组结构，另一个解码单个结构并将其存储在数据库中。 为保存而必须调用的函数因类型而异。

为了决定传递的是数组还是结构，尝试将接口转换为类型，然后将其作为 function 的参数适当传递。与文档和 stackoverflow帖子中的描述类似。

但是，我没有得到预期的具体类型，程序总是运行到默认部分。 我做错了什么或者我没有考虑到？

这些是默认部分的输出：

# interface is a struct
... or a single repository struct: map[string]interface{}

# interface is an array of structs
... or a single repository struct: []interface{}

下面是带有函数的源代码

func (rh *RouteHandler) AddOrUpdateRepository(rw http.ResponseWriter, req *http.Request) {
    repository := new(types.Repository)
    rh.addOrUpdateRepositories(rw, req, repository)
}

func (rh *RouteHandler) AddOrUpdateRepositories(rw http.ResponseWriter, req *http.Request) {
    repositories := make([]*types.Repository, 0)
    rh.addOrUpdateRepositories(rw, req, repositories)
}

func (rh *RouteHandler) addOrUpdateRepositories(rw http.ResponseWriter, req *http.Request, v interface{}) {
    defer req.Body.Close()

    switch req.Header.Get("Content-Type") {
    case "application/xml":
        xmlDecoder := xml.NewDecoder(req.Body)
        err := xmlDecoder.Decode(&v)
        if err != nil {
            rw.WriteHeader(http.StatusInternalServerError)
            fmt.Fprintf(rw, "Failed to decode repositories or repository")
            rh.ulogger.Error("Failed to decode repositories or repository: %v", err)
            return
        }
    case "application/json":
        fallthrough
    default:
        jsonDecoder := json.NewDecoder(req.Body)
        err := jsonDecoder.Decode(&v)
        if err != nil {
            rw.WriteHeader(http.StatusInternalServerError)
            fmt.Fprintf(rw, "Failed to decode repositories or repository")
            rh.ulogger.Error("Failed to decode repositories or repository: %v", err)
            return
        }
    }

    var err error
    switch x := v.(type) {
    case map[string]*types.Repository:
        for _, repository := range x {
            err = rh.manager.AddOrUpdateRepository(context.Background(), repository)
        }
    case *types.Repository:
        err = rh.manager.AddOrUpdateRepository(context.Background(), x)
    case map[string][]*types.Repository:
        for i := range x {
            for j := range x[i] {
                err = rh.manager.AddOrUpdateRepository(context.Background(), x[i][j])
            }
        }
    case []*types.Repository:
        err = rh.manager.AddOrUpdateRepository(context.Background(), x...)
    case nil:
        rw.WriteHeader(http.StatusInternalServerError)
        fmt.Fprintf(rw, "Failed to cast interface")
        rh.ulogger.Error("Failed to cast interface. Interface is a type of nil")
        return
    default:
        rw.WriteHeader(http.StatusInternalServerError)
        fmt.Fprintf(rw, "Failed to cast interface")
        rh.ulogger.Error("Failed to cast interface. Interface does not match onto an array of repositories or a single repository struct: %T", x)
        return
    }

    if err != nil {
        rw.WriteHeader(http.StatusInternalServerError)
        fmt.Fprintf(rw, "Failed to add repositories or repository")
        rh.ulogger.Error("Failed to add repositories or repository: %v", err)
        return
    }
    rw.WriteHeader(http.StatusCreated)

}

Answer 1

（简化了一点。）

您有一个带有以下签名的 function：

func addOrUpdateRepositories(v interface{})

然后你这样称呼它：

repository := new(types.Repository)
addOrUpdateRepositories(repository)

像这样：

repositories := make([]*types.Repository, 0)
addOrUpdateRepositories(repositories)

在第一次调用中，存储在v中的值的具体类型将是*types.Repository （因为new返回指向分配值的指针），在第二次调用中，存储在v中的值的具体类型将是[]*types.Repository因为这就是make被告知要创建的东西。

现在你在v上做一个类型转换，上面写着：

switch x := v.(type) {
case map[string]*types.Repository:
case map[string][]*types.Repository:
case nil:
default:
}

撇开如果你不调用addOrUpdateRepositories传递给它nil v这在你的问题的片段中不会发生的情况， switch将始终选择默认分支，因为存储在v中的具体值的类型永远不会map[string]*types.Repository或map[string][]*types.Repository 。

我不确定您为什么看不到这一点，所以您可能应该完善您的问题，或者可以尝试在对我的回答发表评论时消除您的困惑？

---

黑暗中的另一个镜头：类型转换（注意 Go 没有类型转换，正如@Flimzy 指出的那样）和 Go 中的类型转换实际上并没有改变它们所操作的值的底层表示——除了有限的 ( “每个人都期待这个”）案例，例如将float64类型转换为int64 ，这些案例都有精确的记录。

所以你不能拿一个[]*types.Repository （一片指向类型types.Repository的值的指针）并以某种方式强迫它“变成” map[string][]*types.Repository ：那是一件荒谬的事情出于多种原因，最明显的是：如果您正在编写 Go 编译器，您将如何执行这样的“类型转换”？ 假设你真的要分配一个 map，但是那个 map 中的哪个键应该被分配原始（源）片？ 将[]*types.Repository类型转换为struct {foo []*types.Repository; bar []*types.Repository}怎么样？ struct {foo []*types.Repository; bar []*types.Repository} ？