Comment vider des structures avec des champs non exportés dans des tableaux d'octets dans Go sans réflexion ?

Dumping Struct into Byte Array sans réflexion

La question découle d'un problème rencontré lors de l'utilisation du package d'encodage/binaire pour vider les structures en octets tableaux. Étant donné que le package repose sur la réflexion, il ne parvient pas à gérer les champs de structure non exportés (sans majuscules). Le souci vient de la tentative de maintenir l'abstraction de certaines structures de données.

Solution

Pour vider les structures avec des champs non exportés dans des tableaux d'octets sans réflexion, pensez à utiliser le gob emballer. Ce package fournit des capacités de sérialisation et de désérialisation efficaces et indépendantes de la plate-forme. En implémentant les interfaces GobEncoder et GobDecoder pour les structures avec des champs non exportés, vous pouvez efficacement sérialiser et désérialiser leur contenu.

Vous trouverez ci-dessous un exemple illustrant l'utilisation du package gob :

package main

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

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

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

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

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

    // Writing
    enc := gob.NewEncoder(buffer)
    err := enc.Encode(d)
    if err != nil {
        log.Fatal("encode error:", err)
    }

    // Reading
    buffer = bytes.NewBuffer(buffer.Bytes())
    e := new(Data)
    dec := gob.NewDecoder(buffer)
    err = dec.Decode(e)
    fmt.Println(e, err)
}

Par en implémentant ces interfaces, vous pouvez sérialiser et désérialiser les champs de structure non exportés sans avoir besoin de réflexion, garantissant ainsi le dumping correct des structurer les données en tableaux d'octets.

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!