Interfejsy wiersza poleceń (CLI) są nadal popularne, nawet w obliczu graficznych interfejsów użytkownika (GUI) i ich interaktywnych elementów wizualnych. CLI są nadal w użyciu ze względu na ich prostotę, łatwość, szybkość i mniej zasobów wymaganych do skonfigurowania aplikacji CLI.

Większość aplikacji CLI działa na terminalu lub wierszu poleceń systemu operacyjnego, co zwiększa elastyczność bez konieczności stosowania tak wielu zasobów, jak GUI.

Możesz tworzyć CLI przy użyciu popularnych języków, od Pythona po C++, Rust i Go. Większość języków zapewnia pakiety do tworzenia aplikacji CLI bez zewnętrznych zależności.

Aplikacje Go i wiersza poleceń

Jednym z zamierzonych przypadków użycia języka programowania Go jest budowanie wydajnych, interaktywnych interfejsów CLI. Z biegiem lat Go zyskało popularność w terenie.

Go obsługuje popularne aplikacje CLI, takie jak Docker CLI, Hugo, GitHub CLI i inne. Go jest jednym z preferowanych języków do tworzenia aplikacji CLI, biorąc pod uwagę jego pierwszorzędną obsługę i wydajność.

Jest flaga pakiet do analizowania z wiersza poleceń, ale brakuje mu wielu funkcji potrzebnych do tworzenia nowoczesnych aplikacji z wiersza poleceń. Również tworzenie aplikacji CLI z flaga Pakiet może być złożony w miarę wzrostu rozmiaru aplikacji i dołączania większej liczby funkcji.

Ekosystem Go zawiera wiele renomowanych pakietów do tworzenia interfejsów CLI, z funkcjami pomagającymi skrócić czas programowania.

Pakiet Cobra

Kobra to jeden z najpopularniejszych pakietów do budowania CLI w ekosystemie Go i poza nim. Cobra to pakiet do tworzenia interaktywnych, nowoczesnych aplikacji CLI w dowolnym środowisku.

Cobra zapewnia prosty interfejs do tworzenia interfejsów CLI zgodnych ze standardami branżowymi, podobnymi do narzędzi Go i Git. Cobra obsługuje wiele aplikacji CLI, z którymi miałeś do czynienia, w tym Docker, Kubernetes, Twitch, Hugo i wiele innych.

Cobra to łatwe w użyciu narzędzie oparte na podkomendach. Obsługuje flagi zgodne z POSIX, zagnieżdżone podkomendy oraz flagi globalne, lokalne i kaskadowe.

Cobra obsługuje również inteligentne sugestie, automatyczne generowanie pomocy, rozpoznawanie flag i aliasy poleceń. Pozwala na autouzupełnianie powłoki w Bash, Powershell, Fish i Zsh oraz integrację z żmija pakiet dla aplikacji 12-czynnikowych.

Uruchom to polecenie w terminalu swojego katalogu roboczego, aby zainstalować najnowszą wersję pakietu Cobra i jego zależności.

Iść pobierz -u github.com/spf13/cobra@latest

Cobra zapewnia aplikację CLI dla szybszego i łatwiejszego programowania. Pakiet Cobra—cli generuje kod wzorcowy, który można skonfigurować w celu bezproblemowego dodawania nowych poleceń do aplikacji.

Uruchom to polecenie w terminalu swojego katalogu roboczego, aby zainstalować najnowszą wersję pakietu Cobra-cli.

Iść zainstaluj https://github.com/spf13/cobra-cli@latest

Musisz ustawić zmienną GOPATH w swoim katalogu roboczym, aby móc korzystać z generatora Cobra (Cobra-cli) i innych narzędzi wiersza poleceń Go.

Po pomyślnej instalacji możesz zainicjować aplikację Cobra w swoim projekcie za pomocą w tym Komenda.

cobra-cli init

Po zainicjowaniu aplikacji Cobra możesz użyć dodać podkomenda z cobra cli polecenie, aby utworzyć i dodać nowe polecenie do aplikacji Cobra.

cobra-cli dodaje nowe polecenie

Polecenie tworzy nowy plik z kodem potrzebnym do wykonania polecenia. Możesz edytować plik na podstawie swojej operacji.

Oto prosta funkcja obsługi poleceń dla polecenia wygenerowanego za pomocą polecenia Cobra-cli.

import (
 "fmt"
 "github.com/spf13/cobra"
 "dziennik"
 "strconv"
)
// polecenie wygenerowane przez kobrę


// newCmd reprezentuje nowe polecenie
rozm nowyCmd = &kobra. Komenda {
 Użyj: „nowyCmd”,
 Krótki: „Określony przez ciebie opis newCmd”,
 Długi: `Dłuższy opis obejmujący wiele wierszy i prawdopodobnie zawierający przykłady
i użycie twojego polecenia. Na przykład:
Cobra to biblioteka CLI Do Go, który wzmacnia aplikacje.
Ta aplikacja jest narzędziem do generowania potrzebnych plików
aby szybko stworzyć aplikację Cobra.`,


Uruchomić: funkcja(cmd *kobra. Polecenie, argumenty []strunowy) { 
JeśliLen(argumenty) < 1 { 
 dziennik. Fatal("Brak dodatkowych argumentów")
 }
 argumenty := argumenty [0] 
 fmt. Println (argumenty) 
 }
}


funkcjaw tym() {
 rootCmd. AddCommand (nowe polecenie)


// Tutaj zdefiniujesz swoje flagi i ustawienia konfiguracyjne.


// Cobra obsługuje trwałe flagi, które będą działać dla tego polecenia
// i wszystkie podkomendy, np.:
// nowyCmd. PersistentFlags().String("foo", "", "Pomoc dla foo")
// Cobra obsługuje lokalne flagi, które będą działać tylko wtedy, gdy to polecenie
// jest wywoływany bezpośrednio, np.:
// nowyCmd. Flags().BoolP("toggle", "t", false, "Komunikat pomocy dla przełącznika")
}

Możesz uzyskać dostęp do dodatkowych argumentów za pomocą argumenty argument funkcji. Powyższa funkcja wykorzystuje Jeśli instrukcja, aby sprawdzić, czy jest dodatkowy argument z terminala i drukuje argument.

Pakiet CLI

Pakiet Cli to minimalistyczny pakiet o tematyce ekspresyjnej do tworzenia szybkich, dystrybuowalnych aplikacji CLI w Go.

Pakiet Cli obsługuje argumenty wiersza poleceń, flagi i polecenia podrzędne z kategoriami. Posiada funkcjonalność obsługi krótkich opcji, Uzupełnienia Bash, generowana pomoc i wersjonowanie.

Pakiet Cli jest kompatybilny z wbudowanym Go flaga I kontekst pakietów i możesz korzystać z większości funkcji w flaga pakiet z Cli.

Uruchom te polecenia w terminalu swojego katalogu roboczego, aby dodać pakiet Graphql-go i jego zależności do swojego projektu.

Iść wejdź na github.com/urfave/cli

Oto jak możesz dodać polecenie do swojej aplikacji CLI za pomocą pakietu Cli.

pakiet główny
import (
 "fmt"
 "dziennik"
 „os”


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


funkcjagłówny() {
 aplikacja := &cli. Aplikacja {
 Nazwa: "nowy",
 Stosowanie: "robić A nowy polecenie z Cli pakiet",
 Działanie: funkcja(* kl. Kontekst)błąd {
 fmt. Println("Oto a nowy Komenda")
powrótzero
 },
 }
Jeśli Błąd:= aplikacja. Biegnij (os. argumenty); błąd!= zero {
 dziennik. Fatalny (błąd)
 }
}

w główny funkcja, tzw aplikacja zmienna jest instancją aplikacji Cli i aplikacji Działanie pole jest funkcją obsługi aplikacji. Tutaj nowy polecenie wydrukuje tekst z funkcji lub zwróci błąd, jeśli wystąpią jakieś błędy z aplikacji.

Pakiet Cli jest pomocny w przypadku mniejszych projektów bez większej złożoności i funkcji.

Pakiet Go-Arg

Pakiet Go-arg to pakiet oparty na strukturach do analizowania argumentów CLI w Go. Dzięki pakietowi Go-arg możesz deklarować struktury dla argumentów CLI i operować na argumentach jako zwykłych strukturach danych Go. Pakiet Go-arg zapewnia wymagane argumenty, argumenty pozycyjne, zmienne środowiskowe, łańcuchy użycia, wartości domyślne i wiele innych funkcji.

Pakiet obsługuje podstawowe typy, takie jak liczby całkowite, zmiennoprzecinkowe, łańcuchowe i logiczne. Obsługuje również bardziej złożone typy, takie jak adresy URL, czasy trwania, adresy e-mail, Adresy MAC, wskaźniki, plasterki, mapy i każdy typ.

Możesz użyć Dostawać polecenie, aby dodać pakiet Go-arg do zależności pakietu.

Iść wejdź na github.com/alexflint/Iść-arg

Pakiet Go-arg jest prosty i intuicyjny w obsłudze. Oto jak możesz zaakceptować argumenty z wiersza poleceń i wydrukować je w konsoli wiersza poleceń.

funkcjagłówny() {
rozm argumenty struktura {
 bla strunowy
 Bar bool
 }
 arg. Analiza MustParse(&args)
 fmt. Println (argumenty. Fuj, argumenty. Bar)
}

The argumenty struct jest instancją struct dla aplikacji CLI. The Musiprzeanalizować metoda analizuje argumenty z wiersza poleceń do instancji struktury.

Możesz łatwo uruchomić program za pomocą uruchomić polecenie i podaj argumenty po nazwie pliku.

Iść uruchom główny.Iść --foo=cześć --bar

Możesz także skorzystać z tzw zbudować polecenie, aby zbudować aplikację w pliku wykonywalnym przed uruchomieniem pliku wykonywalnego i określeniem argumentów.


Iść zbuduj główny.Iść
./main --foo=cześć --bar

Istnieją znaczące różnice między GUI a CLI, które należy wziąć pod uwagę

Jeśli w trakcie programowania musisz wybrać między budowaniem CLI a GUI dla swoich użytkowników, będziesz musiał wziąć pod uwagę wiele czynników, aby dokonać wyboru.

Używanie CLI zamiast GUI skutkuje szybszymi programami, łatwą automatyzacją i mniejszym wykorzystaniem zasobów. Jeśli którakolwiek z tych zalet nie jest kluczowa dla Twojej aplikacji, może być lepiej z GUI, ponieważ są one bardziej popularne wśród zwykłych użytkowników.