Unmarshalling JSON à certain type (chaîne) toujours

Question

J'ai un certain JSON qui peut avoir un nombre ou une chaîne comme premier élément. Je veux toujours être en mesure de stocker cela comme une valeur de chaîne, mais à la place, je reçois un plantage car il est en train de le lire comme à juste titre un type de numéro.

J'ai essayé de forcer le unmarshalling comme une chaîne mais cela n'a pas réussi.

string `json:",string"` 

Je suivais ce guide qui semble correspondre mes données bien.

Comment puis-je toujours obtenir cet élément à [0] pour toujours lire et enregistrer sous forme de chaîne?

code & Playground ci-dessous ...

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 
} 

Answer 1

Vous pouvez créer un récepteur universel, par exemple de type d'interface, puis faire une affirmation de type:

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

Answer 2

Essayez Si cela permet de résoudre ce problème, créez une interface générique lorsque l'entrée utilisateur n'est pas définie.

interface{} `json:",string"` 

package

principal

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