Comment générer un script Bash avec des commandes spécifiques basées sur des types de dépendances à l'aide du modèle Golang, de l'instruction switch et de la boucle ForEach ?

Génération de scripts Bash avec modèle Golang, Switch et ForEach

Défi

L'objectif consiste à créer un script Bash à partir d'un programme Golang. Le script doit parcourir les dépendances, identifier leurs types à l'aide d'une instruction switch et faire écho à différentes commandes en fonction du type.

Implémentation

Pour y parvenir, nous pouvons utiliser Accédez aux modèles, qui constituent un moyen pratique de générer des fichiers texte à partir de données structurées. Voici une solution utilisant des modèles avec switch et ForEach :

<code class="go">package main

import (
    "log"
    "text/template"
    "gopkg.in/yaml.v2"
    "os"
)

type File struct {
    TypeVersion string        `yaml:"_type-version"`
    Dependency  []Dependency `yaml:"dependency"`
}

type Dependency struct {
    Name    string            `yaml:"name"`
    Type    string            `yaml:"type"`
    CWD     string            `yaml:"cwd"`
    Install map[string]string `yaml:"install"`
}

var data = `
_type-version: "1.0.0"
dependency:
  - name: ui
    type: runner
    cwd: /ui
    install:
       - name: api

  - name: ui2
    type: runner2
    cwd: /ui2
    install:
       - name: api2

`

func main() {
    f := File{}

    err := yaml.Unmarshal([]byte(data), &f)
    if err != nil {
        log.Fatalf("error: %v", err)
    }

    const t = `
#!/bin/bash

{{range .Dependency}}
echo "type is {{.Type}}"
{{switch .Type}}
    case "runner":
        echo "running command for runner"
    case "runner2":
        echo "running command for runner2"
    default:
        echo "unknown type"
{{end}}
{{end}}
`

    tt := template.Must(template.New("").Parse(t))
    err = tt.Execute(os.Stdout, f)
    if err != nil {
        log.Println("executing template:", err)
    }
}</code>

Explication

1. Nous utilisons un fichier YAML (données) pour définir les dépendances et leurs types .
2. Nous analysons le fichier YAML dans une structure File en utilisant yaml.Unmarshal.
3. Nous définissons un modèle (t) en utilisant text/template. Le modèle comprend une boucle ForEach pour parcourir les dépendances et une instruction switch pour gérer différents types.
4. Nous analysons le modèle à l'aide de template.Parse et l'exécutons en utilisant Execute avec la structure File en entrée.
5. Cela génère le script Bash avec les commandes souhaitées en fonction des types de dépendances.

Sortie

L'exécution du programme ci-dessus produit la sortie suivante :

#!/bin/bash

type is runner
running command for runner
type is runner2
running command for runner2

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!