通过函数作为“接口{}”后恢复类型信息？

Question

我现在在使用 Golang 时遇到了一个轻微的架构问题，这导致我复制/粘贴的代码比我希望的要多。我觉得必须有一个解决方案，所以请让我知道这是否可能：

当我通过interface {}-typed 函数参数传递东西时，我开始收到诸如“预期的结构或切片”等错误......即使我之前传递的是结构或切片。我意识到我可以在该函数中收到它们后手动将它们转换为另一种类型，但是在这样的实例中变得乏味：

本地接口类型 *interface {} 只能从远程解码 接口类型；收到具体类型

...在这种情况下，接收函数似乎需要硬编码才能将所有interface {} 项目转换回它们各自的原始类型才能正常工作，因为接收函数需要知道准确的类型，以便正确处理项目。

有没有办法将 Golang interface {} 类型化的变量动态重新输入到它们的原始类型？ 像这样，How to I convert reflect.New's return value back to the original type ... 可能吗？

---

编辑：为了澄清，基本上，我将&out 传递给一个函数，并且在它到达另一个内部函数调用时它必须是它的原始类型。

示例代码：

// NOTE: This is sort of pseudo-Golang code, not meant to be compiled or taken too seriously.

func PrepareTwoDifferentThings(keyA string, keyB string) {
    var somethingA TypeA;
    var somethingB TypeB;

    loadFromCache(keyA, &somethingA, nil);
    loadFromCache(keyB, &somethingB, nil);

    fmt.Printf("Somethings: %v, %v", somethingA, somethingB);

}

func loadFromCache(key string, isNew, out interface {}, saveNewData interface {}) {
    if err := cache.load(key, &out); err!=nil { // NOTE: Current issue is that this expects "&out" to be `TypeA`/`TypeB` not "interface {}", but I don't want to copy and paste this whole function's worth of code or whatever.
        panic("oh no!");

    }

    if (saveNewData!=nil) {
        cache.save(key, saveNewData); // This doesn't seem to care if "saveNewData" is "interface {}" when saving, but later cache fetches above using the "load()" method to an "interface {}"-typed `&out` parameter throw an exception that the "interface {}" type on `&out` does not match the original when it was saved here (`TypeA`/`TypeB`).

    }

}

Answer 1

要将接口的类​​型更改为正确的类型，您可以使用type assertions：

package main

import r "reflect"

type A struct {
    Name string
}

func main() {
    // No pointer
    aa := A{"name"}
    var ii interface{} = aa

    bb := ii.(A)
    // main.A

    // Pointer
    a := &A{"name"}
    var i interface{} = a

    b := *i.(*A)
    // main.A

    c := i.(*A)
    // *main.A

    d := r.Indirect(r.ValueOf(i)).Interface().(A)
    // main.A
}

Playground 1

使用类型断言时，您必须知道接口的底层类型。在 Go 中，无法将类型断言与动态类型一起使用。 reflect.Type 不是类型，它是表示类型的接口。所以不，你不能这样使用它。

如果您有多种类型的可能性，解决方案是type switch：

package main

import "fmt"

type TypeA struct {
    A string
}

type TypeB struct {
    B string
}

func doSomethingA(t TypeA) {
    fmt.Println(t.A)
}

func doSomethingB(t TypeB) {
    fmt.Println(t.B)
}

func doSomething(t interface{}) {
    switch t := t.(type) {
    case TypeA:
        doSomethingA(t)
    case TypeB:
        doSomethingB(t)
    default:
        panic("Unrecognized type")
    }
}

func main() {
    a := TypeA{"I am A"}
    b := TypeB{"I am B"}

    doSomething(a)
    // I am A
    doSomething(b)
    // I am B
}

Playground 2

Answer 2

事实证明，使用JSON 而不是Gob 进行序列化可以完全避免我遇到的错误。其他函数可以处理传入接口等。