Je me propose de réaliser dans cet article un panorama des parseurs YAML en Go. Pour chacun d'entre eux, je fournis une brève description, une évaluation et un exemple de code.
À noter que les noms des parseurs ont été changés par mes soins dans la mesure où tous ces parseurs s'appellent goyaml :o)
Dans les codes d'exemple, nous parserons le fichier YAML suivant :
foo: 1
bar:
- one
- two
Dans chacun des sources, nous extraierons et afficherons le premier élément de la liste se trouvant sous la clé foo du tableau associatif au premier niveau.
Ce parseurs est très pratique pour charger des fichiers de configuration. Pour ce faire, il suffit de déclarer une struct ayant la structure du fichier YAML à charger et de passer une référence à cette structure au parseur lors du chargement. Le parseur va alors peupler la structure avec les données du fichier YAML.
Ce parseur est probablement la meilleure option pour charger des fichiers de configuration YAML.
Gypsy est un parseur bas niveau, ce qui veut dire que le parsing d'un fichier renverra un arbre de noeuds qu'il vous faudra explorer à la main (comme dans l'exemple suivant) :
package main
import (
"fmt"
"github.com/kylelemons/go-gypsy/yaml"
"os"
)
func nodeToMap(node yaml.Node) (yaml.Map) {
m, ok := node.(yaml.Map)
if !ok {
panic(fmt.Sprintf("%v is not of type map", node))
}
return m
}
func nodeToList(node yaml.Node) (yaml.List) {
m, ok := node.(yaml.List)
if !ok {
panic(fmt.Sprintf("%v is not of type list", node))
}
return m
}
func main() {
filename := os.Args[1]
file, err := yaml.ReadFile(filename)
if err != nil {
panic(err)
}
value := nodeToList(nodeToMap(file.Root)["bar"])[0]
fmt.Printf("Value: %#v\n", value)
}
Pour exévuter cet exemple, on pourra taper la commande suivante :
package main
import (
"fmt"
"github.com/beego/goyaml2"
"os"
)
func nodeToMap(node interface{}) map[string]interface{} {
m, ok := node.(map[string]interface{})
if !ok {
panic(fmt.Sprintf("%v is not of type map", node))
}
return m
}
func nodeToList(node interface{}) []interface{} {
m, ok := node.([]interface{})
if !ok {
panic(fmt.Sprintf("%v is not of type list", node))
}
return m
}
func main() {
filename := os.Args[1]
file, err := os.Open(filename)
if err != nil {
panic(err)
}
object, err := goyaml2.Read(file)
if err != nil {
panic(err)
}
value := nodeToList(nodeToMap(object)["bar"])[0]
fmt.Printf("Value: %#v\n", value)
}
C'est une surcouche à GoYAML pour simplifier le parsing de fichiers YAML. On n'a pas à décrire la structure du document, on accède directement au contenu par exploration de l'arbre. Cependant, ce qu'on économise d'un côté (la description de la structure du document), on le perd de l'autre (code pour explorer l'arbre et gérer les erreurs)...
