Unmarshal yaml mappant les clés de dict aux propriétés de la structure

l'éditeur php Xigua vous présente aujourd'hui une technique très utile : désorganiser YAML dans un dictionnaire et mapper les clés aux attributs structurels. YAML est un format léger de sérialisation de données couramment utilisé pour les fichiers de configuration et l'échange de données. En désorganisant YAML, nous pouvons le convertir en dictionnaire, puis mapper les clés du dictionnaire aux propriétés structurelles, ce qui nous permet d'effectuer plus facilement d'autres opérations et traitements dans le code. Cette technique est très utile lorsqu'il s'agit de fichiers de configuration ou de chargement de données à partir de sources de données externes. Jetons un coup d'œil à la méthode d'implémentation spécifique !

Contenu de la question

J'ai cherché ici pendant un moment mais je n'ai pas trouvé de réponse appropriée :

J'essaie de désorganiser une clé de dict yaml sur les attributs d'une structure au lieu de clés mappées. Compte tenu de ce yaml

commands:
    php:
        service: php
        bin: /bin/php
    node:
        service: node
        bin: /bin/node

J'ai pu le regrouper dans une structure comme celle-ci :

type config struct {
    commands map[string]struct {
        service string
        bin     string
    }
}

Mais comment puis-je le déconstruire en une structure comme celle-ci :

type Config struct {
    Commands []struct {
        Name    string    // <-- this should be key from the yaml (i.e. php or node)
        Service string
        Bin     string
    }
}

Merci d'avance pour votre aide

Solution de contournement

Vous pouvez écrire un unmarshaller personnalisé comme celui-ci (terrain de jeu en déplacement) :

package main

import (
    "fmt"

    "gopkg.in/yaml.v3"
)

var input []byte = []byte(`
commands:
    php:
        service: php
        bin: /bin/php
    node:
        service: node
        bin: /bin/node
`)

type Command struct {
    Service string
    Bin     string
}

type NamedCommand struct {
    Command
    Name string
}

type NamedCommands []NamedCommand

type Config struct {
    Commands NamedCommands
}

func (p *NamedCommands) UnmarshalYAML(value *yaml.Node) error {
    if value.Kind != yaml.MappingNode {
        return fmt.Errorf("`commands` must contain YAML mapping, has %v", value.Kind)
    }
    *p = make([]NamedCommand, len(value.Content)/2)
    for i := 0; i < len(value.Content); i += 2 {
        var res = &(*p)[i/2]
        if err := value.Content[i].Decode(&res.Name); err != nil {
            return err
        }
        if err := value.Content[i+1].Decode(&res.Command); err != nil {
            return err
        }
    }
    return nil
}

func main() {
    var f Config
    var err error
    if err = yaml.Unmarshal(input, &f); err != nil {
        panic(err)
    }
    for _, cmd := range f.Commands {
        fmt.Printf("%+v\n", cmd)
    }
}

J'ai divisé les données de commande en command 和 namedcommand 以使代码更简单，因为您只需调用 decode 即可提供嵌入的 command valeurs de la structure. Si tout est dans la même structure, vous devrez mapper manuellement les clés aux champs de structure.

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!