Wie generiert man ein Bash-Skript mit spezifischen Befehlen basierend auf Abhängigkeitstypen mithilfe einer Golang-Vorlage, einer Switch-Anweisung und einer ForEach-Schleife?

Bash-Skriptgenerierung mit Golang-Vorlage, Switch und ForEach

Herausforderung

Das Ziel besteht darin, ein Bash-Skript aus einem Golang-Programm zu erstellen. Das Skript sollte Abhängigkeiten durchlaufen, ihre Typen mithilfe einer Switch-Anweisung identifizieren und verschiedene Befehle basierend auf dem Typ wiedergeben.

Implementierung

Um dies zu erreichen, können wir verwenden Go-Vorlagen, die eine bequeme Möglichkeit bieten, Textdateien aus strukturierten Daten zu generieren. Hier ist eine Lösung, die Vorlagen mit Schalter und ForEach verwendet:

<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>

Erklärung

1. Wir verwenden eine YAML-Datei (Daten), um die Abhängigkeiten und ihre Typen zu definieren .
2. Wir analysieren die YAML-Datei mit yaml.Unmarshal in eine Dateistruktur.
3. Wir definieren eine Vorlage (t) mit text/template. Die Vorlage enthält eine ForEach-Schleife zum Durchlaufen von Abhängigkeiten und eine Switch-Anweisung zur Verarbeitung verschiedener Typen.
4. Wir analysieren die Vorlage mit template.Parse und führen sie mit Execute mit der Dateistruktur als Eingabe aus.
5. Dadurch wird das Bash-Skript mit den gewünschten Befehlen basierend auf den Abhängigkeitstypen generiert.

Ausgabe

Das Ausführen des obigen Programms erzeugt die folgende Ausgabe:

#!/bin/bash

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

Das obige ist der detaillierte Inhalt vonWie generiert man ein Bash-Skript mit spezifischen Befehlen basierend auf Abhängigkeitstypen mithilfe einer Golang-Vorlage, einer Switch-Anweisung und einer ForEach-Schleife?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!