Comment sérialiser des structures avec des champs non exportés dans un tableau d'octets sans réflexion ?

Dumping Struct in Byte Array sans réflexion

Lorsque vous travaillez avec des structures qui ont des champs non exportés, les encoder en données binaires peut être un défi. Bien que le package d'encodage/binaire offre une solution, son recours à la réflexion peut entraîner des problèmes avec les champs non exportés.

Solution alternative

Pour surmonter cette limitation, envisagez d'utiliser le paquet gob. Le package gob fournit un moyen simple et efficace de sérialiser et désérialiser les structures de données, même celles comportant des champs privés. Voici comment l'implémenter :

1. Implémentez les fonctions GobEncode et GobDecode :
   Définissez ces fonctions pour les structures avec des champs non exportés. Ces fonctions guideront le package gob dans la sérialisation et la désérialisation des données.
2. Utilisez gob.Encoder et gob.Decoder :
   Créez des instances de gob.Encoder et gob.Decoder pour écrire ou lire les données de structure vers ou depuis un octet buffer.

Exemple

Considérez l'exemple de code suivant :

package main

import (
    "bytes"
    "encoding/gob"
    "fmt"
)

type Data struct {
    id    int32
    name   [16]byte
}

func (d *Data) GobEncode() ([]byte, error) {
    w := new(bytes.Buffer)
    enc := gob.NewEncoder(w)
    err := enc.Encode(d.id)
    if err != nil {
        return nil, err
    }
    err = enc.Encode(d.name)
    if err != nil {
        return nil, err
    }
    return w.Bytes(), nil
}

func (d *Data) GobDecode(buf []byte) error {
    r := bytes.NewBuffer(buf)
    dec := gob.NewDecoder(r)
    err := dec.Decode(&d.id)
    if err != nil {
        return err
    }
    return dec.Decode(&d.name)
}

func main() {
    d := Data{id: 7}
    copy(d.name[:], []byte("tree"))
    buffer := new(bytes.Buffer)

    // Write
    enc := gob.NewEncoder(buffer)
    err := enc.Encode(d)
    if err != nil {
        fmt.Println("Encode error:", err)
        return
    }

    // Read
    buffer = bytes.NewBuffer(buffer.Bytes())
    e := new(Data)
    dec := gob.NewDecoder(buffer)
    err = dec.Decode(e)
    if err != nil {
        fmt.Println("Decode error:", err)
        return
    }
    fmt.Println(e)
}

En suivant cette approche, vous pouvez efficacement vider et récupérer struct les données avec des champs non exportés dans un tableau d'octets sans compter sur la réflexion.

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!