英文:
Unmarshalling JSON to certain type (string) always
问题
我有一些 JSON 数据,第一个元素可以是数字或字符串。我希望始终将其存储为字符串值,但实际上它被读取为数字类型,导致程序崩溃。
我尝试强制将其解析为字符串,但没有成功。
string `json:",string"`
我正在遵循这个指南,它似乎很适合我的数据。
如何确保始终将位于 [0] 的元素读取并保存为字符串?
以下是代码和 Playground 链接...
https://play.golang.org/p/KP4_1xPJiZ
package main
import "fmt"
import "log"
import "encoding/json"
const inputWorking = `
["AAAAAA", {"testcode" : "Sss"}, 66666666]
`
const inputBroken = `
[111111, {"testcode" : "Sss"}, 66666666]
`
type RawMessage struct {
AlwaysString string `json:",string"`
ClientData ClientData
ReceptionTime int
}
type ClientData struct {
testcode string
}
func main() {
var n RawMessage
if err := json.Unmarshal([]byte(inputWorking), &n); err != nil {
log.Fatal(err)
}
fmt.Printf("%#v\n", n)
var o RawMessage
if err := json.Unmarshal([]byte(inputBroken), &o); err != nil {
log.Fatal(err)
}
fmt.Printf("%#v\n", o)
}
func (n *RawMessage) UnmarshalJSON(buf []byte) error {
tmp := []interface{}{&n.AlwaysString, &n.ClientData, &n.ReceptionTime}
wantLen := len(tmp)
if err := json.Unmarshal(buf, &tmp); err != nil {
return err
}
if g, e := len(tmp), wantLen; g != e {
return fmt.Errorf("wrong number of fields in RawMessage: %d != %d", g, e)
}
return nil
}
英文:
I have some JSON that can have either a number or a string as the first element. I always want to be able to store this as a string value but instead I get a crash as it is reading it as quite rightly so a number type.
I tried to force the unmarshalling as a string but this was not successful.
string `json:",string"`
I am following this guide which seems to fit my data nicely.
How can I always get this element at [0] to always read and save as a string?
Code & Playground below...
https://play.golang.org/p/KP4_1xPJiZ
package main
import "fmt"
import "log"
import "encoding/json"
const inputWorking = `
["AAAAAA", {"testcode" : "Sss"}, 66666666]
`
const inputBroken = `
[111111, {"testcode" : "Sss"}, 66666666]
`
type RawMessage struct {
AlwaysString string `json:",string"`
ClientData ClientData
ReceptionTime int
}
type ClientData struct {
testcode string
}
func main() {
var n RawMessage
if err := json.Unmarshal([]byte(inputWorking), &n); err != nil {
log.Fatal(err)
}
fmt.Printf("%#v\n", n)
var o RawMessage
if err := json.Unmarshal([]byte(inputBroken), &o); err != nil {
log.Fatal(err)
}
fmt.Printf("%#v\n", o)
}
func (n *RawMessage) UnmarshalJSON(buf []byte) error {
tmp := []interface{}{&n.AlwaysString, &n.ClientData, &n.ReceptionTime}
wantLen := len(tmp)
if err := json.Unmarshal(buf, &tmp); err != nil {
return err
}
if g, e := len(tmp), wantLen; g != e {
return fmt.Errorf("wrong number of fields in RawMessage: %d != %d", g, e)
}
return nil
}
答案1
得分: 3
你可以创建一个通用的接收器,即接口类型,并进行类型断言:
package main
import (
"encoding/json"
"fmt"
)
type RawMessage struct {
UnknownType interface{} `json:"unknown_type"`
}
const inputString = `{"unknown_type" : "a"}`
const inputFloat = `{"unknown_type" : 123}` // 注意:默认情况下解组为float64类型!!!
func main() {
var n RawMessage
if err := json.Unmarshal([]byte(inputFloat), &n); err != nil {
println(err.Error())
}
switch v := n.UnknownType.(type) {
case string:
fmt.Printf("接收到一个字符串:%v", v)
case float64:
fmt.Printf("接收到一个数字:%v", v)
default:
fmt.Printf("未知类型:%v", v)
}
}
英文:
You can create a universal receiver, i.e. of interface type, and then do a type assertion:
package main
import (
"encoding/json"
"fmt"
)
type RawMessage struct {
UnknownType interface{} `json:"unknown_type"`
}
const inputString = `{"unknown_type" : "a"}`
const inputFloat = `{"unknown_type" : 123}` // Note: Unmarshals into a float64 by default!!!
func main() {
var n RawMessage
if err := json.Unmarshal([]byte(inputFloat), &n); err != nil {
println(err.Error())
}
switch v := n.UnknownType.(type) {
case string:
fmt.Printf("Received a string: %v", v)
case float64:
fmt.Printf("Received a number: %v", v)
default:
fmt.Printf("Unknown type: %v", v)
}
}
答案2
得分: 3
我遇到了同样的问题,到目前为止,我找到的最好的解决办法是使用自定义的解码器将字符串转换为类型:
package main
import (
"encoding/json"
"fmt"
"strconv"
)
// Stringish exists because api send back integers unquoted even if underlying type is string
type StringIsh string
func (f *StringIsh) UnmarshalJSON(data []byte) error {
var receiver string
if len(data) == 0 {
return nil
}
if data[0] != '"' {
quoted := strconv.Quote(string(data))
data = []byte(quoted)
}
if err := json.Unmarshal(data, &receiver); err != nil {
return err
}
*f = StringIsh(receiver)
return nil
}
type Test struct {
Foo StringIsh
}
func main() {
dest := &Test{}
_ = json.Unmarshal([]byte(`{"foo": "bar"}`), &dest)
fmt.Println(dest)
dest = &Test{}
_ = json.Unmarshal([]byte(`{"foo": 123}`), &dest)
fmt.Println(dest)
}
你可以在 https://goplay.space/#i0OVs9tnule 上自行尝试。
英文:
I had the same problem and so far the best I found was to make a type from string with a custom unmarshaller:
package main
import (
"encoding/json"
"fmt"
"strconv"
)
// Stringish exists because api send back integers unquoted even if underlying type is string
type StringIsh string
func (f *StringIsh) UnmarshalJSON(data []byte) error {
var receiver string
if len(data) == 0 {
return nil
}
if data[0] != '"' {
quoted := strconv.Quote(string(data))
data = []byte(quoted)
}
if err := json.Unmarshal(data, &receiver); err != nil {
return err
}
*f = StringIsh(receiver)
return nil
}
type Test struct {
Foo StringIsh
}
func main() {
dest := &Test{}
_ = json.Unmarshal([]byte(`{"foo": "bar"}`), &dest)
fmt.Println(dest)
dest = &Test{}
_ = json.Unmarshal([]byte(`{"foo": 123}`), &dest)
fmt.Println(dest)
}
Try it yourself at https://goplay.space/#i0OVs9tnule
答案3
得分: -1
尝试这个方法,将用户输入定义为通用接口:
interface{} `json:",string"`
package main
import "fmt"
import "log"
import "encoding/json"
const inputWorking = `
["AAAAAA", {"testcode" : "Sss"}, 66666666]
`
const inputBroken = `
[111111, {"testcode" : "Sss"}, 66666666]
`
type RawMessage struct {
AlwaysString interface{} `json:",string"`
ClientData ClientData
ReceptionTime int
}
type ClientData struct {
testcode string
}
func main() {
var n RawMessage
if err := json.Unmarshal([]byte(inputWorking), &n); err != nil {
log.Fatal(err)
}
fmt.Printf("%#v\n", n)
var o RawMessage
if err := json.Unmarshal([]byte(inputBroken), &o); err != nil {
log.Fatal(err)
}
}
以上是代码的翻译。
英文:
Try this if it resolve this issue, make a generic interface as user input is not defined
interface{} `json:",string"`
package main
import "fmt"
import "log"
import "encoding/json"
const inputWorking = `
["AAAAAA", {"testcode" : "Sss"}, 66666666]
`
const inputBroken = `
[111111, {"testcode" : "Sss"}, 66666666]
`
type RawMessage struct {
AlwaysString interface{} `json:",string"`
ClientData ClientData
ReceptionTime int
}
type ClientData struct {
testcode string
}
func main() {
var n RawMessage
if err := json.Unmarshal([]byte(inputWorking), &n); err != nil {
log.Fatal(err)
}
fmt.Printf("%#v\n", n)
var o RawMessage
if err := json.Unmarshal([]byte(inputBroken), &o); err != nil {
log.Fatal(err)
}
通过集体智慧和协作来改善编程学习和解决问题的方式。致力于成为全球开发者共同参与的知识库,让每个人都能够通过互相帮助和分享经验来进步。
评论