Pourquoi mon Go Byte Slice se convertit-il en une « chaîne étrange » lorsqu'il est marshalé en JSON ?

Dépannage de la conversion octet en JSON : "chaîne étrange" rencontrée

Dans le domaine du marshaling JSON, tentative de transformation d'une tranche d'octets ([]octet) en JSON donne souvent un résultat inattendu : une chaîne apparemment étrange. Examinons les raisons derrière cela et explorons la méthode appropriée pour la conversion JSON.

La nature de la « chaîne étrange »

Telle que documentée dans la bibliothèque standard Go (https://golang. org/pkg/encoding/json/#Marshal), les tranches d'octets sont gérées de manière unique lors du marshaling JSON. Au lieu d'être directement convertis en tableaux JSON, ils sont codés en base64 pour produire une chaîne. Cela conduit souvent à des résultats déroutants.

Un exemple pratique

Considérez l'extrait de code suivant :

package main

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

func main() {
    type ColorGroup struct {
        ByteSlice []byte
    }
    group := ColorGroup{
        ByteSlice: []byte{0, 0, 0, 1, 2, 3},
    }
    b, err := json.Marshal(group)
    if err != nil {
        fmt.Println("error:", err)
    }
    os.Stdout.Write(b)
}

L'exécution de ce code produit le résultat suivant :

{"ByteSlice":"AAAAAQID"}

La "chaîne étrange" AAAAAQID est la représentation codée en base64 de la tranche d'octets [0 0 0 1 2 3].

Restauration de la tranche d'octets

Pour récupérer la tranche d'octets d'origine de la chaîne encodée, vous pouvez utiliser le package base64 dans Go :

package main

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

func main() {
    type ColorGroup struct {
        ByteSlice []byte
    }
    group := ColorGroup{}

    b, err := json.Marshal(group)
    if err != nil {
        fmt.Println("error:", err)
    }
    err = json.Unmarshal(b, &group)
    if err != nil {
        fmt.Println("error:", err)
    }

    decodedBytes, err := base64.StdEncoding.DecodeString(group.ByteSlice)
    if err != nil {
        fmt.Println("error:", err)
    }
    fmt.Println(decodedBytes)
}

Résultat :

[0 0 0 1 2 3]

Conclusion

Comprendre pourquoi les tranches d'octets présenter ce comportement lors du marshaling JSON est crucial pour gérer efficacement les données. En utilisant les mécanismes d'encodage et de décodage base64, la conversion transparente entre les tranches d'octets et les données JSON devient une tâche simple.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!