Convertir Go carte en json

J'ai essayé de convertir ma carte pour une chaîne json avec encoding/json Maréchal, mais elle a abouti à une chaîne vide.

Voici mon code :

package main

import (
    "encoding/json"
    "fmt"
)

type Foo struct {
    Number int    `json:"number"`
    Title  string `json:"title"`
}

func main() {
    datas := make(map[int]Foo)

    for i := 0; i < 10; i++ {
        datas[i] = Foo{Number: 1, Title: "test"}
    }

    jsonString, _ := json.Marshal(datas)

    fmt.Println(datas)
    fmt.Println(jsonString)
}

Mon résultat est :

map[9:{1 test} 2:{1 test} 7:{1 test} 3:{1 test} 4:{1 test} 5:{1 test} 6:{1 test} 8:{1 test} 0:{1 test} 1:{1 test}]

[]

Je ne sais vraiment pas où je me trompe. Je vous remercie pour votre aide.

  • Merci de ne pas downvote sans donner un commentaire. Je pense que la question est une bonne question (+1): il contient tout le code, il contient une question précise, la sortie, ... C'est totalement dans le sujet et l'OP a fait beaucoup d'effort pour poser une bonne question. C'est vraiment une honte d'avoir les downvotes ici!
  • Le problème ne proviennent du fait que l'OP explicitement ignore l'erreur, qui aurait répondu à la question imediately.
  • Je suis clairement conscience que j'avais tort. Deux erreurs en une seule question. Vous pouvez être sûr que je ne vais pas les répéter.
InformationsquelleAutor Cronos87 | 2014-07-09
  1. 85

    Si vous aviez pris l'erreur, tu aurais vu ceci:

    jsonString, err := json.Marshal(datas)
fmt.Println(err)

//[] json: unsupported type: map[int]main.Foo

    La chose est que vous ne pouvez pas utiliser des nombres entiers comme les clés en JSON; il est interdit. Au lieu de cela, vous pouvez convertir ces valeurs à cordes à l'avance, par exemple en utilisant des strconv.Itoa.

    Voir ce post pour plus de détails: https://stackoverflow.com/a/24284721/2679935

    • Ici vous pouvez voir comment les types de carte: golang.org/pkg/encoding/json/#Unmarshal Vous pouvez utiliser une tranche au lieu de cela, ce qui correspond à un tableau JSON. Aussi: toujours vérifier les erreurs 😉
    • Je suppose que le comportement a changé. Voir golang.org/pkg/encoding/json/#Unmarshal pour "La carte du type de clé doit être une chaîne de caractères, un entier de type, ou de mettre en œuvre le codage.TextMarshaler."
    • Apparemment, il a changé en Aller 1.7 (golang.org/doc/go1.7#encoding_json), mais il ne fait toujours pas ce que vous attendez: play.golang.org/p/0aFaQ_ByOk
    • est-il un moyen de le faire avec une synchronisation.Carte?
    • Je n'ai pas utilisé d'Aller dans des années, je ne serai pas en mesure de répondre à votre question... Peut-être essayer de créer une nouvelle question sur LE!
    InformationsquelleAutor julienc
  2. 25

    Il raconte en fait ce qui est mal, mais vous avez ignoré parce que vous n'avez pas vérifier l'erreur renvoyée par json.Marshal.

    json: unsupported type: map[int]main.Foo

    JSON spec ne supporte pas de rien, sauf des chaînes pour les clés de l'objet, tandis que le javascript ne pas être pointilleux à ce sujet, il est toujours illégal.

    Vous avez deux options:

    1 Utilisation map[string]Foo et de convertir l'indice en chaîne (à l'aide de l'esf.Le Sprint par exemple):

    datas := make(map[string]Foo, N)

for i := 0; i < 10; i++ {
    datas[fmt.Sprint(i)] = Foo{Number: 1, Title: "test"}
}
j, err := json.Marshal(datas)
fmt.Println(string(j), err)

    2 il suffit juste d'utiliser une tranche (tableau javascript):

    datas2 := make([]Foo, N)
for i := 0; i < 10; i++ {
    datas2[i] = Foo{Number: 1, Title: "test"}
}
j, err = json.Marshal(datas2)
fmt.Println(string(j), err)

    jeux

    • Vous avez raison. C'est une honte d'erreur... je ne sais pas vraiment pourquoi j'ai utilisé un int pour un json clé... Merci pour vos exemples.
    InformationsquelleAutor OneOfOne
  3. 2

    Depuis que cette question a été posée/dernière réponse, le soutien à la chaîne de types de clés pour les cartes de json Maréchal/UnMarshal a été ajoutée par le biais de l'utilisation de TextMarshaler et TextUnmarshaler interfaces ici. Vous pourriez mettre en œuvre ces interfaces pour vos types de clés et alors json.Marshal ne fonctionnent pas comme prévu.

    package main

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

//Num wraps the int value so that we can implement the TextMarshaler and TextUnmarshaler 
type Num int

func (n *Num) UnmarshalText(text []byte) error {
    i, err := strconv.Atoi(string(text))
    if err != nil {
        return err
    }
    *n = Num(i)
    return nil
}

func (n Num) MarshalText() (text []byte, err error) {
    return []byte(strconv.Itoa(int(n))), nil
}

type Foo struct {
    Number Num    `json:"number"`
    Title  string `json:"title"`
}

func main() {
    datas := make(map[Num]Foo)

    for i := 0; i < 10; i++ {
        datas[Num(i)] = Foo{Number: 1, Title: "test"}
    }

    jsonString, err := json.Marshal(datas)
    if err != nil {
        panic(err)
    }

    fmt.Println(datas)
    fmt.Println(jsonString)

    m := make(map[Num]Foo)
    err = json.Unmarshal(jsonString, &m)
    if err != nil {
        panic(err)
    }

    fmt.Println(m)
}

    De sortie: 

    map[1:{1 test} 2:{1 test} 4:{1 test} 7:{1 test} 8:{1 test} 9:{1 test} 0:{1 test} 3:{1 test} 5:{1 test} 6:{1 test}]
[123 34 48 34 58 123 34 110 117 109 98 101 114 34 58 34 49 34 44 34 116 105 116 108 101 34 58 34 116 101 115 116 34 125 44 34 49 34 58 123 34 110 117 109 98 101 114 34 58 34 49 34 44 34 116 105 116 108 101 34 58 34 116 101 115 116 34 125 44 34 50 34 58 123 34 110 117 109 98 101 114 34 58 34 49 34 44 34 116 105 116 108 101 34 58 34 116 101 115 116 34 125 44 34 51 34 58 123 34 110 117 109 98 101 114 34 58 34 49 34 44 34 116 105 116 108 101 34 58 34 116 101 115 116 34 125 44 34 52 34 58 123 34 110 117 109 98 101 114 34 58 34 49 34 44 34 116 105 116 108 101 34 58 34 116 101 115 116 34 125 44 34 53 34 58 123 34 110 117 109 98 101 114 34 58 34 49 34 44 34 116 105 116 108 101 34 58 34 116 101 115 116 34 125 44 34 54 34 58 123 34 110 117 109 98 101 114 34 58 34 49 34 44 34 116 105 116 108 101 34 58 34 116 101 115 116 34 125 44 34 55 34 58 123 34 110 117 109 98 101 114 34 58 34 49 34 44 34 116 105 116 108 101 34 58 34 116 101 115 116 34 125 44 34 56 34 58 123 34 110 117 109 98 101 114 34 58 34 49 34 44 34 116 105 116 108 101 34 58 34 116 101 115 116 34 125 44 34 57 34 58 123 34 110 117 109 98 101 114 34 58 34 49 34 44 34 116 105 116 108 101 34 58 34 116 101 115 116 34 125 125]
map[4:{1 test} 5:{1 test} 6:{1 test} 7:{1 test} 0:{1 test} 2:{1 test} 3:{1 test} 1:{1 test} 8:{1 test} 9:{1 test}]
    InformationsquelleAutor vim