JSON unmarshaling mit langen Nummern gibt Gleitkommazahl

War ich marshaling und unmarshaling JSONs mit golang und wenn ich will, es zu tun mit der Anzahl Felder golang verwandelt es in floating-point-zahlen anstelle von langen Nummern, zum Beispiel.

Habe ich folgenden JSON:

{
    "id": 12423434, 
    "Name": "Fernando"
}

Nach marshal es zu einer Karte und unmarshal wieder einen json-string, den ich bekommen:

{
    "id":1.2423434e+07,
    "Name":"Fernando"
}

Wie Sie sehen können die "id" Feld ist in Gleitkommadarstellung.

Den code, den ich verwende, ist folgende:

package main

import (
    "encoding/json"
    "fmt"
    "os"
)

func main() {

    //Create the Json string
    var b = []byte(`
        {
        "id": 12423434, 
        "Name": "Fernando"
        }
    `)

    //Marshal the json to a map
    var f interface{}
    json.Unmarshal(b, &f)
    m := f.(map[string]interface{})

    //print the map
    fmt.Println(m)

    //unmarshal the map to json
    result,_:= json.Marshal(m)

    //print the json
    os.Stdout.Write(result)

}

Er druckt:

map[id:1.2423434e+07 Name:Fernando]
{"Name":"Fernando","id":1.2423434e+07}

Scheint es zu sein, dass die erste marshal auf der Karte erzeugt der FP. Wie kann ich es beheben zu lange?

Dies ist der link zu dem Programm in der goland-Spielplatz:
http://play.golang.org/p/RRJ6uU4Uw-

Nicht der Marschall in einem map[string]interface{} aber eine richtige Struktur mit z.B. einem int64 Feld für id.

InformationsquelleAutor Fersca | 2014-03-12

floating-point go json marshalling

69

Es gibt Zeiten, wenn Sie nicht definieren kann, eine Struktur, die im Voraus bedürfen jedoch noch die zahlen zu Durchlaufen, die Marschall-unmarshal-Prozess unverändert.

In diesem Fall können Sie die UseNumber Methode auf json.Decoder, die bewirkt, dass alle zahlen mit unmarshal als json.Number (das ist nur die ursprüngliche string-Repräsentation der Zahl). Dies kann auch nützlich für die Speicherung von sehr großen ganzen zahlen im JSON-Format.

Beispiel:
```
package main

import (
    "strings"
    "encoding/json"
    "fmt"
    "log"
)

var data = `{
    "id": 12423434, 
    "Name": "Fernando"
}`

func main() {
    d := json.NewDecoder(strings.NewReader(data))
    d.UseNumber()
    var x interface{}
    if err := d.Decode(&x); err != nil {
        log.Fatal(err)
    }
    fmt.Printf("decoded to %#v\n", x)
    result, err := json.Marshal(x)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("encoded to %s\n", result)
}
```
Ergebnis:
```
decoded to map[string]interface {}{"id":"12423434", "Name":"Fernando"}
encoded to {"Name":"Fernando","id":12423434}
```
- Schön! Das war das, was ich suchte, werde ich versuchen, es zu verwenden und feedback geben.
- Toll, ich hatte Bedenken, dass die echten Schwimmer kommen auch wieder zu zahlen. Zum Glück ist es nicht: play.golang.org/p/TRo0v4yeBO
- Das scheint wie die Antwort, wenn Sie noch um, akzeptieren Sie es vielleicht?
InformationsquelleAutor rog
15

Den JSON-standard nicht hat, sehnt sich oder schwimmt, es sind nur zahlen. Die json Paket übernehmen wird, float64, wenn Sie noch nicht definiert etwas anderes (Bedeutung, nur Unmarshal mit einem interface{}).

Was Sie tun sollten ist, um eine ordnungsgemäße erstellen struct (wie Volker bereits erwähnt):
```
package main

import (
    "encoding/json"
    "fmt"
    "os"
)

type Person struct {
    Id   int64  `json:"id"`
    Name string `json:"name"`
}

func main() {

    //Create the Json string
    var b = []byte(`{"id": 12423434, "Name": "Fernando"}`)

    //Marshal the json to a proper struct
    var f Person
    json.Unmarshal(b, &f)

    //print the person
    fmt.Println(f)

    //unmarshal the struct to json
    result, _ := json.Marshal(f)

    //print the json
    os.Stdout.Write(result)
}
```
Ergebnis:

{12423434 Fernando}

{"id":12423434,"name":"Fernando"}

Spielplatz: http://play.golang.org/p/2R76DYVgMK

Edit:

Im Falle einer dynamischen json-Struktur und möchten, um die Vorteile einer struct, kann man es lösen mit json.RawMessage. Eine variable vom Typ json.RawMessage speichern die rohen JSON-Zeichenfolge, so dass Sie später, wenn Sie wissen, welche Art von Objekt es enthält, können unmarshal es in die richtige Struktur. Egal welche Lösung Sie verwenden, werden Sie auf jeden Fall brauchen einige if oder switch Anweisung, wo Sie bestimmen, welche Art von Struktur es ist.

Es ist auch nützlich, wenn Teile der JSON-Daten nur kopiert werden, um ein weiteres JSON-Objekt, z.B. mit der id-Wert eines JSON-RPC-Anfrage.

Beispiel der container-Struktur mit json.RawMessage und die entsprechenden JSON-Daten:
```
type Container struct {
    Type string          `json:"type"`
    Data json.RawMessage `json:"data"`
}

var b = []byte(`{"type": "person", "data":{"id": 12423434, "Name": "Fernando"}}`)
```
Einer modifizierten version von deinem Beispiel auf dem Spielplatz: http://play.golang.org/p/85s130Sthu

Edit2:

Wenn Sie die Struktur der JSON-Wert wird auf der Grundlage der name eines name/Wert-paar, Sie können das gleiche tun mit einem:
```
type Container map[string]json.RawMessage
```
- Der Kommentar "//Marschall von json auf eine Karte" soll wurden geändert, um "//Marschall von json zu einem struct".
- Ich habe gerade bemerkt, dass ich übersehen die Kommentare. Fixed it "struct"
- Das problem y ich bin die Speicherung von verschiedenen json-Strukturen, so weiß ich nicht, die wäre de struct vor dem Lesen der json
- Dann haben Sie wahrscheinlich auch ein paar Felder, die würde Ihnen sagen, welche Struktur Sie sind etwa zu Lesen. Siehe mein edit auf, wie solche dynamischen Datenstrukturen.
InformationsquelleAutor ANisus

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.