Pourquoi « json.Marshal » de Go convertit-il []byte en une chaîne base64, et comment puis-je y remédier ?

Marshaling []byte vers JSON : décodage de chaînes mystérieuses

Lorsqu'ils tentent de convertir une tranche d'octets ([]byte) au format JSON, les développeurs rencontrent souvent des représentations de chaînes inattendues . Cet article examine les raisons de ce comportement et propose une solution pour rassembler les tranches d'octets avec précision.

Le cas déroutant

Considérez l'extrait de code suivant :

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

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

Quand exécuté, ce code affiche :

{"ByteSlice":"AAAAAQID","SingleByte":10,"IntSlice":[0,0,0,1,2,3]}

Intriguant, le champ ByteSlice, qui doit contenir un tableau d'octets, a été rendu comme "AAAAAQID".

Démêler le mystère

L'explication réside dans la documentation du package json :

Les valeurs de tableau et de tranche encodent sous forme de tableaux JSON, sauf que []byte est codé comme une chaîne codée en base64 et qu'une tranche nulle est codée comme un JSON nul objet.

Dans ce cas, le champ ByteSlice, un tableau d'octets, n'est pas codé comme un tableau JSON mais plutôt comme une chaîne codée en base64.

Une solution : décodage Base64

Pour marshaler les données []byte vers JSON comme prévu, il est nécessaire de décoder la représentation base64. Voici une version mise à jour du code :

package main

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

func main() {
    type ColorGroup struct {
        ByteSlice    []byte
        SingleByte   byte
        IntSlice     []int
    }
    group := ColorGroup{
        ByteSlice:  []byte{0, 0, 0, 1, 2, 3},
        SingleByte: 10,
        IntSlice:   []int{0, 0, 0, 1, 2, 3},
    }
    // Decode ByteSlice from base64 before marshaling
    decodedByteSlice, err := base64.StdEncoding.DecodeString(string(group.ByteSlice))
    if err != nil {
        fmt.Println("error:", err)
    }
    group.ByteSlice = decodedByteSlice
    b, err := json.Marshal(group)
    if err != nil {
        fmt.Println("error:", err)
    }
    os.Stdout.Write(b)
}

Maintenant, la sortie JSON résultante représente correctement le champ ByteSlice sous la forme d'un tableau d'octets :

{"ByteSlice":[0,0,0,1,2,3],"SingleByte":10,"IntSlice":[0,0,0,1,2,3]}

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!