Kommandoradsgränssnitt (CLI) är fortfarande populära även inför grafiska användargränssnitt (GUI) och deras interaktiva visuella komponenter. CLI: er används fortfarande på grund av deras enkelhet, lätthet, hastighet och färre resurser som krävs för att konfigurera en CLI-applikation.
De flesta CLI-appar körs på operativsystemets terminal eller kommandorad, vilket ökar flexibiliteten utan att kräva lika många resurser som GUI.
Du kan bygga CLI: er med populära språk från Python till C++, Rust och Go. De flesta språk tillhandahåller paket för att bygga CLI-appar utan externa beroenden.
Gå och kommandoradsapplikationer
Ett av de avsedda användningsfallen för programmeringsspråket Go är att bygga prestanda interaktiva CLI: er. Genom åren har Go fått fäste i fältet.
Go driver populära CLI-applikationer som Docker CLI, Hugo, GitHub CLI och mer. Go är ett av de föredragna språken för att bygga CLI-appar, med tanke på dess förstklassiga stöd för dem tillsammans med dess prestanda.
Det finns en flagga
paket för kommandoradsanalys, men det saknar mycket funktionalitet som du behöver för att bygga moderna kommandoradsappar. Dessutom utvecklar CLI-appar med flagga paketet kan vara komplext eftersom storleken på din app ökar och du införlivar fler funktioner.Go-ekosystemet har många välrenommerade paket för att bygga CLI: er, med funktioner som hjälper till att minska din utvecklingstid.
Cobra-paketet
Kobra är ett av de mest populära paketen för att bygga CLI: er i Go-ekosystemet och vidare. Cobra är ett paket för att skapa interaktiva, moderna CLI-appar i vilken miljö som helst.
Cobra tillhandahåller ett enkelt gränssnitt för att bygga CLI: er av industristandard liknande Go-verktyg och Git. Cobra driver många CLI-applikationer du har interagerat med, inklusive Docker, Kubernetes, Twitch, Hugo och en mängd andra.
Cobra är ett lättanvänt, underkommandobaserat verktyg. Den stöder POSIX-kompatibla flaggor, kapslade underkommandon och globala, lokala och överlappande flaggor.
Cobra stöder också intelligenta förslag, automatisk hjälpgenerering, flaggigenkänning och kommandoalias. Det möjliggör skalautokomplettering på Bash, Powershell, Fish och Zsh, och integration med huggorm paket för 12-faktorappar.
Kör det här kommandot i terminalen i din arbetskatalog för att installera den senaste versionen av Cobra-paketet och dess beroenden.
gå få -u github.com/spf13/cobra@latest
Cobra tillhandahåller en CLI-app för snabbare och enklare utveckling. Cobra—cli-paketet genererar kod som du kan konfigurera för att lägga till nya kommandon till din app utan krångel.
Kör det här kommandot i terminalen i din arbetskatalog för att installera den senaste versionen av Cobra-cli-paketet.
gå installera github.com/spf13/cobra-cli@latest
Du måste ställa in din GOPATH-variabel till din arbetskatalog för att använda Cobra-generatorn (Cobra-cli) och andra Go-kommandoradsverktyg.
Efter en lyckad installation kan du initiera en Cobra-app i ditt projekt med i det kommando.
cobra-cli init
Efter att ha initierat en Cobra-app kan du använda Lägg till underkommando med kobra-cli kommando för att skapa och lägga till ett nytt kommando i din Cobra-app.
cobra-cli lägg till nytt kommando
Kommandot skapar en ny fil med koden du behöver för kommandot. Du kan redigera filen baserat på din operation.
Här är en enkel kommandohanterarfunktion för ett kommando som genereras med kommandot Cobra-cli.
importera (
"fmt"
"github.com/spf13/cobra"
"logga"
"strconv"
)// ett kobra-genererat kommando
// newCmd representerar det nya kommandot
var newCmd = &cobra. Kommando {
Använd: "newCmd",
Kort: "Den nya Cmd-beskrivningen du anger",
Lång: `En längre beskrivning som sträcker sig över flera rader och sannolikt innehåller exempel
och användningen av att använda ditt kommando. Till exempel:
Cobra är ett CLI-bibliotek för Go som ger applikationer möjlighet.
Denna applikation är ett verktyg för att generera de nödvändiga filerna
för att snabbt skapa en Cobra-applikation.`,Springa: func(cmd *kobra. Kommando, args []sträng) {
omlen(args) < 1 {
logga. Fatal("Inga ytterligare argument")
}
argument := args[0]
fmt. Println (argument)
}
}funci det() {
rootCmd. AddCommand (newCmd)// Här kommer du att definiera dina flaggor och konfigurationsinställningar.
// Cobra stöder Persistent Flags som fungerar för detta kommando
// och alla underkommandon, t.ex.:
// newCmd. PersistentFlags().String("foo", "", "En hjälp för foo")
// Cobra stöder lokala flaggor som bara körs när detta kommando
// anropas direkt, t.ex.:
// newCmd. Flags().BoolP("toggle", "t", false, "Hjälpmeddelande för växla")
}
Du kan komma åt ytterligare argument med args argument för funktionen. Funktionen ovan använder om uttalande för att kontrollera om det finns ytterligare ett argument från terminalen och skriver ut argumentet.
CLI-paketet
Cli-paketet är ett minimalistiskt paket med expressivitetstema för att bygga snabba, distribuerbara CLI-appar i Go.
Cli-paketet stöder kommandoradsargument, flaggor och underkommandon med kategorier. Den har funktionalitet för att tillgodose korta alternativ, Bash-avslut, genererad hjälp och versionshantering.
Cli-paketet är interoperabelt med Gos inbyggda flagga och sammanhang paket, och du kan använda de flesta av funktionerna i flagga paket med Cli.
Kör dessa kommandon i terminalen i din arbetskatalog för att lägga till Graphql-go-paketet och dess beroenden till ditt projekt.
gå hämta github.com/urfave/cli
Så här kan du lägga till ett kommando till din CLI-app med Cli-paketet.
paket huvudimportera (
"fmt"
"logga"
"os""github.com/urfave/cli/v2"
)funchuvud() {
app := &cli. App {
Namn: "ny",
Användning: "göra a ny kommandot med Cli paket",
Handling: func(*cli. Sammanhang)fel {
fmt. Println("Här är en ny kommando")
lämna tillbakanoll
},
}
om fel := app. Kör (os. Args); fel!= noll {
logga. Dödlig (fel)
}
}
I den huvud funktion, den app variabel är en instans av en Cli-app och applikationens Handling fältet är appens hanterarfunktion. Här, den ny kommandot skulle skriva ut texten från funktionen eller returnera ett fel om det finns några fel från appen.
Cli-paketet är användbart för mindre projekt utan mycket komplexitet eller funktioner.
Go-Arg-paketet
Go-arg-paketet är ett strukturbaserat paket för att analysera CLI-argument i Go. Med Go-arg-paketet kan du deklarera strukturer för CLI-argument och arbeta på argumenten som vanliga Go-datastrukturer. Go-arg-paketet tillhandahåller nödvändiga argument, positionsargument, miljövariabler, användningssträngar, standardvärden och många andra funktioner.
Paketet stöder grundläggande typer som heltal, flyttal, sträng och boolean. Det stöder också mer komplexa typer som webbadresser, tidslängder, e-postadresser, MAC-adresser, pekare, skivor, kartor och några typ.
Du kan använda skaffa sig kommandot för att lägga till Go-arg-paketet till ditt pakets beroenden.
gå skaffa github.com/alexflint/gå-arg
Go-arg-paketet är enkelt och intuitivt att använda. Så här kan du acceptera argument från kommandoraden och skriva ut dem till kommandoradskonsolen.
funchuvud() {
var args struktur {
Foo sträng
Bar bool
}
arg. MustParse(&args)
fmt. Println (args. Foo, args. Bar)
}
De args struct är struct-instansen för CLI-applikationen. De MustParse metoden analyserar argumenten från kommandoraden till struct-instansen.
Du kan enkelt köra programmet med springa kommandot och ange argumenten efter filnamnet.
gå kör main.gå --foo=hej --bar
Du kan också använda bygga kommando för att bygga din app till en körbar fil innan du kör den körbara och specificerar argumenten.
gå bygga huvud.gå
./main --foo=hej --bar
Det finns betydande skillnader mellan GUI: er och CLI: er du måste överväga
Under utvecklingen, om du måste välja mellan att bygga ett CLI eller GUI för dina användare, måste du ta hänsyn till många faktorer för att göra ett val.
Att använda CLI: er över GUI: er resulterar i snabbare program, enkel automatisering och lägre resursutnyttjande. Om någon av dessa fördelar inte är avgörande för din applikation, kanske du har det bättre med ett GUI eftersom de är mer populära bland vanliga användare.