Befehlszeilenschnittstellen (CLIs) sind trotz grafischer Benutzerschnittstellen (GUIs) und ihrer interaktiven visuellen Komponenten immer noch beliebt. CLIs werden aufgrund ihrer Einfachheit, Leichtigkeit, Geschwindigkeit und der geringeren Ressourcen, die zum Einrichten einer CLI-Anwendung erforderlich sind, immer noch verwendet.

Die meisten CLI-Apps werden auf dem Terminal oder der Befehlszeile des Betriebssystems ausgeführt, was die Flexibilität erhöht, ohne so viele Ressourcen wie GUIs zu beanspruchen.

Sie können CLIs mit gängigen Sprachen von Python bis C++, Rust und Go erstellen. Die meisten Sprachen bieten Pakete zum Erstellen von CLI-Apps ohne externe Abhängigkeiten.

Go- und Befehlszeilenanwendungen

Einer der beabsichtigten Anwendungsfälle für die Programmiersprache Go ist das Erstellen performanter interaktiver CLIs. Im Laufe der Jahre hat Go auf dem Gebiet an Bedeutung gewonnen.

Go unterstützt beliebte CLI-Anwendungen wie Docker CLI, Hugo, GitHub CLI und mehr. Go ist eine der bevorzugten Sprachen zum Erstellen von CLI-Apps, da es neben seiner Leistung auch erstklassige Unterstützung dafür bietet.

instagram viewer

Da ist ein Flagge Paket für die Befehlszeilenanalyse, aber es fehlen viele Funktionen, die Sie zum Erstellen moderner Befehlszeilen-Apps benötigen. Auch das Entwickeln von CLI-Apps mit dem Flagge -Paket kann komplex werden, wenn die Größe Ihrer App zunimmt und Sie mehr Funktionen integrieren.

Das Go-Ökosystem bietet viele seriöse Pakete zum Erstellen von CLIs mit Funktionen zur Verkürzung Ihrer Entwicklungszeit.

Das Cobra-Paket

Kobra ist eines der beliebtesten Pakete zum Erstellen von CLIs im Go-Ökosystem und darüber hinaus. Cobra ist ein Paket zum Erstellen interaktiver, moderner CLI-Apps in jeder Umgebung.

Cobra bietet eine einfache Schnittstelle zum Erstellen von CLIs nach Industriestandard, ähnlich wie Go-Tools und Git. Cobra unterstützt viele CLI-Anwendungen, mit denen Sie interagiert haben, darunter Docker, Kubernetes, Twitch, Hugo und viele andere.

Cobra ist ein benutzerfreundliches, auf Unterbefehlen basierendes Tool. Es unterstützt POSIX-kompatible Flags, verschachtelte Unterbefehle sowie globale, lokale und kaskadierende Flags.

Cobra unterstützt auch intelligente Vorschläge, automatische Hilfegenerierung, Flag-Erkennung und Befehlsaliase. Es ermöglicht die automatische Shell-Vervollständigung auf Bash, Powershell, Fish und Zsh sowie die Integration mit der Viper Paket für 12-Faktor-Apps.

Führen Sie diesen Befehl im Terminal Ihres Arbeitsverzeichnisses aus, um die neueste Version des Cobra-Pakets und seiner Abhängigkeiten zu installieren.

gehen Holen Sie sich -u github.com/spf13/cobra@latest

Cobra bietet eine CLI-App für eine schnellere und einfachere Entwicklung. Das Cobra—cli-Paket generiert Boilerplate-Code, den Sie konfigurieren können, um Ihrer App problemlos neue Befehle hinzuzufügen.

Führen Sie diesen Befehl im Terminal Ihres Arbeitsverzeichnisses aus, um die neueste Version des Cobra-cli-Pakets zu installieren.

gehen installiere github.com/spf13/cobra-cli@latest

Sie müssen Ihre GOPATH-Variable auf Ihr Arbeitsverzeichnis setzen, um den Cobra-Generator (Cobra-cli) und andere Go-Befehlszeilentools verwenden zu können.

Nach erfolgreicher Installation können Sie eine Cobra-App in Ihrem Projekt mit der initialisieren drin Befehl.

cobra-cli init

Nachdem Sie eine Cobra-App initialisiert haben, können Sie die verwenden hinzufügen Unterbefehl mit der cobra-cli Befehl zum Erstellen und Hinzufügen eines neuen Befehls zu Ihrer Cobra-App.

cobra-cli add newCommand

Der Befehl erstellt eine neue Datei mit dem Code, den Sie für den Befehl benötigen. Sie können die Datei basierend auf Ihrer Operation bearbeiten.

Hier ist eine einfache Befehlshandlerfunktion für einen Befehl, der mit dem Cobra-cli-Befehl generiert wurde.

importieren (
 "fmt"
 "github.com/spf13/cobra"
 "Protokoll"
 "strconv"
)
// ein von cobra generierter Befehl


// newCmd repräsentiert den neuen Befehl
Var newCmd = &cobra. Befehl {
 Verwenden Sie: "newCmd",
 Kurz: "Die von Ihnen angegebene newCmd-Beschreibung",
 Lang: `Eine längere Beschreibung, die sich über mehrere Zeilen erstreckt und wahrscheinlich Beispiele enthält
und Verwendung der Verwendung Ihres Befehls. Zum Beispiel:
Cobra ist eine CLI-Bibliothek für Go, das Anwendungen stärkt.
Diese Anwendung ist ein Tool zum Generieren der benötigten Dateien
um schnell eine Cobra-Anwendung zu erstellen.`,


Laufen: Funk(cmd *kobra. Befehl, Argumente []Schnur) { 
Wennlen(Argumente) < 1 { 
 Protokoll. Fatal ("Keine zusätzlichen Argumente")
 }
 Argumente := Argumente[0] 
 fmt. Println (Argumente) 
 }
}


Funkdrin() {
 rootCmd. Befehl hinzufügen (newCmd)


// Hier definieren Sie Ihre Flags und Konfigurationseinstellungen.


// Cobra unterstützt Persistent Flags, die für diesen Befehl funktionieren
// und alle Unterbefehle, z. B.:
// neuerBefehl. PersistentFlags().String("foo", "", "Eine Hilfe für foo")
// Cobra unterstützt lokale Flags, die nur bei diesem Befehl ausgeführt werden
// wird direkt aufgerufen, z.B.:
// neuerBefehl. Flags().BoolP("toggle", "t", false, "Help message for toggle")
}

Mit können Sie auf zusätzliche Argumente zugreifen Argumente Argument der Funktion. Die obige Funktion verwendet die Wenn -Anweisung, um zu prüfen, ob es ein zusätzliches Argument vom Terminal gibt, und gibt das Argument aus.

Das CLI-Paket

Das Cli-Paket ist ein minimalistisches Paket zum Thema Expressivität zum Erstellen schneller, verteilbarer CLI-Apps in Go.

Das Cli-Paket unterstützt Befehlszeilenargumente, Flags und Unterbefehle mit Kategorien. Es hat Funktionen, um Short-Optionen zu berücksichtigen, Bash-Vervollständigungen, generierte Hilfe und Versionierung.

Das Cli-Paket ist mit Gos eingebautem kompatibel Flagge Und Kontext Pakete, und Sie können die meisten Funktionen in der verwenden Flagge Paket mit dem Cli.

Führen Sie diese Befehle im Terminal Ihres Arbeitsverzeichnisses aus, um das Graphql-go-Paket und seine Abhängigkeiten zu Ihrem Projekt hinzuzufügen.

gehen Holen Sie sich github.com/urfave/cli

So können Sie Ihrer CLI-App mit dem Cli-Paket einen Befehl hinzufügen.

Paket hauptsächlich
importieren (
 "fmt"
 "Protokoll"
 "os"


"github.com/urfave/cli/v2"
)


Funkhauptsächlich() {
 app := &cli. Anwendung {
 Name: "neu",
 Verwendung: "machen A neu Befehl mit dem Cli Paket",
 Aktion: Funk(*Kli. Kontext)Fehler {
 fmt. Println("Hier ist ein neu Befehl")
zurückkehrenNull
 },
 }
Wenn ähm := app. Laufen (os. Args); äh != Null {
 Protokoll. Fatal (äh)
 }
}

Im hauptsächlich Funktion, die App Variable ist eine Instanz einer CLI-App und der Anwendung Aktion field ist die Handler-Funktion der App. Hier das neu Der Befehl würde den Text aus der Funktion drucken oder einen Fehler zurückgeben, wenn es Fehler von der App gibt.

Das Cli-Paket ist hilfreich für kleinere Projekte ohne viel Komplexität oder Funktionen.

Das Go-Arg-Paket

Das Go-arg-Paket ist ein strukturbasiertes Paket zum Analysieren von CLI-Argumenten in Go. Mit dem Go-arg-Paket können Sie Strukturen für CLI-Argumente deklarieren und mit den Argumenten als reguläre Go-Datenstrukturen arbeiten. Das Go-arg-Paket stellt erforderliche Argumente, Positionsargumente, Umgebungsvariablen, Verwendungszeichenfolgen, Standardwerte und viele andere Funktionen bereit.

Das Paket unterstützt grundlegende Typen wie Integer, Floating Point, String und Boolean. Es unterstützt auch komplexere Typen wie URLs, Zeitspannen, E-Mail-Adressen, MAC-Adressen, Zeiger, Slices, Karten und die beliebig Typ.

Du kannst den... benutzen erhalten Befehl, um das Go-arg-Paket zu den Abhängigkeiten Ihres Pakets hinzuzufügen.

gehen Holen Sie sich github.com/alexflint/gehen-arg

Das Go-arg-Paket ist einfach und intuitiv zu bedienen. So können Sie Argumente von der Befehlszeile akzeptieren und auf der Befehlszeilenkonsole ausgeben.

Funkhauptsächlich() {
Var Argumente Struktur {
 Foo Schnur
 Bar bool
 }
 Arg. MustParse(&args)
 fmt. Println (args. Foo, arg. Bar)
}

Der Argumente struct ist die struct-Instanz für die CLI-Anwendung. Der MustParse -Methode parst die Argumente von der Befehlszeile in die Struct-Instanz.

Sie können das Programm einfach mit ausführen laufen Befehl und geben Sie die Argumente nach dem Dateinamen an.

gehen Hauptlauf ausführen.gehen --foo=Hallo --bar

Sie können auch die verwenden bauen Befehl, um Ihre App in eine ausführbare Datei zu erstellen, bevor Sie die ausführbare Datei ausführen und die Argumente angeben.


gehen Haupt bauen.gehen
./main --foo=Hallo --bar

Es gibt signifikante Unterschiede zwischen GUIs und CLIs, die Sie berücksichtigen müssen

Wenn Sie sich während der Entwicklung zwischen dem Erstellen einer CLI oder GUI für Ihre Benutzer entscheiden müssen, müssen Sie viele Faktoren berücksichtigen, um eine Wahl zu treffen.

Die Verwendung von CLIs über GUIs führt zu schnelleren Programmen, einfacher Automatisierung und geringerer Ressourcennutzung. Wenn einer dieser Vorteile für Ihre Anwendung nicht entscheidend ist, sind Sie mit einer GUI möglicherweise besser dran, da sie bei allgemeinen Benutzern beliebter sind.