在不同类型上使用相同的方法，并在Go中返回不同的类型值

我见过一些类似的问题

但在我的例子中，我的函数不返回相同的类型

你能更简单地编写下面的代码吗

package main

import (
  "encoding/json"
  "fmt"
)

type A struct {
  Name string `json:"name"`
  Age  int    `json:"age"`
}

type B struct {
  Name    string `json:"name"`
  Age     int    `json:"age"`
  Address string `json:address`
}

func UnmarshalA(b []byte) *A {
  var t *A
  _ = json.Unmarshal(b, &t)
  return t
}

func UnmarshalB(b []byte) *B {
  var t *B
  _ = json.Unmarshal(b, &t)
  return t
}

func main() {
  a := []byte(`{"name": "aaaa", "age": 1}`)
  unmarshal_a := UnmarshalA(a)
  fmt.Println(unmarshal_a.Name)

  b := []byte(`{"name": "bbbb", "age": 2, "address": "b@example.com"}`)
  unmarshal_b := UnmarshalB(b)
  fmt.Println(unmarshal_b.Name)
}

// aaaa
// bbbb

---

您有两个选择

不要麻烦使用

UnmarshalA

和

UnmarshalB

。 他们真的做的不多，你真的只是抽象出一行<代码>变量t*A

如果您实际上不需要

A

和

B

结构，只需要以您可以使用的方式表示JSON字符串的内容，您可以将其解组到

map[string]接口{}

例如

如果您希望通过引用传递数据，则可以将其更改为以下内容：

package main

import (
    "encoding/json"
    "fmt"
)

func UnmarshalAny(b []byte) *map[string]interface{} {
    var t = make(map[string]interface{})
    _ = json.Unmarshal(b, &t)
    return &t
}

func main() {
    a := []byte(`{"name": "aaaa", "age": 1}`)
    unmarshal_a := UnmarshalAny(a)

    b := []byte(`{"name": "bbbb", "age": 2, "address": "b@example.com"}`)
    unmarshal_b := UnmarshalAny(b)

    // Accessed like this...
    fmt.Println((*unmarshal_a)["name"])
    fmt.Println((*unmarshal_b)["name"])
}

---

您有两个选择

不要麻烦使用

UnmarshalA

和

UnmarshalB

。 他们真的做的不多，你真的只是抽象出一行<代码>变量t*A

如果您实际上不需要

A

和

B

结构，只需要以您可以使用的方式表示JSON字符串的内容，您可以将其解组到

map[string]接口{}

例如

如果您希望通过引用传递数据，则可以将其更改为以下内容：

package main

import (
    "encoding/json"
    "fmt"
)

func UnmarshalAny(b []byte) *map[string]interface{} {
    var t = make(map[string]interface{})
    _ = json.Unmarshal(b, &t)
    return &t
}

func main() {
    a := []byte(`{"name": "aaaa", "age": 1}`)
    unmarshal_a := UnmarshalAny(a)

    b := []byte(`{"name": "bbbb", "age": 2, "address": "b@example.com"}`)
    unmarshal_b := UnmarshalAny(b)

    // Accessed like this...
    fmt.Println((*unmarshal_a)["name"])
    fmt.Println((*unmarshal_b)["name"])
}

---

这已经很简单了。我认为在函数UnmarshalA和UnmarshalB中似乎出现了重复。我知道这不是您想要的答案，但对我来说，根本没有

UnmarshalA

和

UnmarshalB

函数似乎更简单：为什么有一个方法包装如此简单的操作？我希望这只是一个简单的例子。。。但我担心它可能简化了重要的一点。这对我来说很像一个XY问题。它已经很简单了。我认为在函数UnmarshalA和UnmarshalB中似乎出现了重复。我知道这不是你想要的答案，但对我来说，根本没有

UnmarshalA

和

UnmarshalB

函数似乎更简单：为什么有一个方法包装这样一个问题还是简单的操作？我希望这只是一个简单的例子。。。但我担心它可能简化了重要的一点。这对我来说很像XY问题。如果我需要a和B结构，我的代码是正确的吗？或者其他任何可以简单编写代码的东西？我可能需要泛型或

go generate

，但我不确定。如果需要A和B结构，请参阅

1在我的答案中。我不确定泛型是否会对您有所帮助，因为在结构被实例化之后，这类事情就会发挥作用。另外，我认为现在甚至不支持泛型。如果我需要A和B结构，我的代码是正确的吗？或者其他任何可以简单编写代码的东西？我可能需要泛型或
go generate
，但我不确定。如果需要A和B结构，请参阅
1在我的答案中。我不确定泛型是否会对您有所帮助，因为在结构被实例化之后，这类事情就会发挥作用。另外，我认为现在甚至不支持泛型。