Comment rassembler des valeurs entières en hexadécimal à l'aide de go-yaml ?

l'éditeur php Banana vous présentera comment utiliser go-yaml pour rassembler des valeurs entières en hexadécimal. go-yaml est une bibliothèque de langage Go pour le traitement des données au format YAML, qui fournit une API simple et facile à utiliser. Pour marshaler une valeur entière en hexadécimal, nous pouvons d'abord convertir l'entier en tranche d'octets, puis utiliser la fonction fmt.Sprintf pour formater la tranche d'octets en une chaîne hexadécimale. Enfin, nous pouvons utiliser la bibliothèque go-yaml pour écrire la chaîne formatée dans un fichier YAML. Cette méthode est simple et efficace et peut répondre à nos besoins. Examinons ensuite de plus près les étapes spécifiques de mise en œuvre.

Contenu de la question

J'ai une structure avec un champ entier qui a du sens pour les humains dans une représentation hexadécimale. Par exemple, définissez-le sur le champ Vendor ID.

Je souhaite enregistrer ces données dans un fichier YAML pour une édition manuelle, puis les charger à partir du fichier. Pour autant que je sache, il n'y a aucun problème avec la représentation hexadécimale des nombres dans YAML lui-même, mais go-yaml （我使用 v3) encode les entiers sous forme décimale, et je n'ai pas trouvé de moyen normal de les enregistrer sous forme hexadécimale.

Prenons comme point de départ le code suivant :

import (
    //...
    "gopkg.in/yaml.v3"
)

type DeviceInfo struct {
    VendorId uint32 `yaml:"vendorid"`
}

func main() {
    deviceInfo := DeviceInfo{VendorId: 0xdeadbeef}

    yml, err := yaml.Marshal(deviceInfo)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(string(yml))
}

Ce code génère YAML avec des valeurs décimales :

vendorid: 3735928559

Ensuite, go-yaml 允许您为自己的类型创建自定义封送拆收器。我这样做了（我故意省略了 fmt.Sprintf() 格式字符串中的 0x préfixe) :

type Uint32Hex uint32

func (U Uint32Hex) MarshalYAML() (interface{}, error) {
    return fmt.Sprintf("%x", U), nil
}

type DeviceInfo struct {
    VendorId Uint32Hex `yaml:"vendorid"`
}

func main() {
    // the same code
}

Ce code génère des valeurs hexadécimales sans le préfixe 0x (logique pour l'instant) :

vendorid: deadbeef

Mais si j'ajoute le préfixe 0x dans le marshaleur personnalisé :

func (U Uint32Hex) MarshalYAML() (interface{}, error) {
    return fmt.Sprintf("0x%x", U), nil
}

La valeur est générée correctement, mais au lieu d'être un nombre, c'est une chaîne :

vendorid: "0xdeadbeef"

Afin de décomposer cette ligne en chiffres, j'ai également dû écrire un démarshaler personnalisé. Je n'aime pas cette solution.

Enfin, j'ai les questions suivantes :

1. Existe-t-il un moyen simple de générer des nombres hexadécimaux à l'aide de go-yaml que je n'ai pas trouvé ?

2. Est-il possible de créer un encodeur personnalisé basé sur go-yaml comme extension d'un package, sans changer le package lui-même ? Pour moi, un moyen plus pratique consiste à passer la balise format dans la description de la structure, par exemple, comme ceci :

   type DeviceInfo struct {
       VendorId uint32 `yaml:"vendorid,hex"`
   }
   

3. Si cela nécessite des modifications du code du package, quelle est l'approche de Go face à cette situation ? Copiez simplement le fichier du package dans mon projet, modifiez-le si nécessaire et importez-le localement ?

Solution de contournement

Le problème ici est que citer des chaînes dans yaml est facultatif, mais go-yaml 使用与 JSON 编码器相同的内部架构。这意味着首先处理自定义封送处理，然后完全独立地应用引用逻辑。 deadbeef 没有被引用，但 0xdeadbeef 被引用的原因是因为后者是一个数字。它被引用，这样当它知道它应该是一个字符串时，它就不会意外地被解组为数字，因为您的自定义封送拆收器返回了一个字符串。由于 deadbeef utilise le même schéma interne que l'encodeur JSON. Cela signifie que le marshaling personnalisé est géré en premier, puis que la logique de citation est appliquée de manière totalement indépendante. deadbeef n'est pas référencé, mais la raison pour laquelle 0xdeadbeef est référencé est que ce dernier

est un nombre

. Il est cité afin qu'il ne soit pas accidentellement transformé en un nombre, car votre marshaleur personnalisé renvoie une chaîne alors qu'il sait qu'il s'agit d'une chaîne. Puisque deadbeef ne peut pas être lu comme un nombre valide, aucun guillemet n'est nécessaire. Vous pouvez faire deux choses :

Marshaling/Unmarshalling personnalisé effectué à partir de chaînes :

1. func (U *Uint32Hex) UnmarshalYAML(value *yaml.Node) error {
       parsed, err := strconv.ParseUint(value.Value, 0, 32)
       *U = Uint32Hex(parsed)
       return err
   }
   

   go-yaml 并修改它。如果您这样做，则不应更改源文件中的导入。相反，您应该将 replace 指令添加到 go.mod
Fork

et modifiez-le. Si vous procédez ainsi, les importations dans le fichier source ne doivent pas être modifiées. Au lieu de cela, vous devez ajouter la directive replace à go.mod comme ceci :

require gopkg.in/yaml.v3 v3.0.1

replace gopkg.in/yaml.v3 v3.0.1 => ../yaml.v3 // Your local path to the fork

🎜Je préfère la solution 1 car elle vous permet de sérialiser les valeurs comme bon vous semble sans vous écarter du yaml généré par d'autres, et ne vous oblige pas à maintenir une branche. 🎜

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!