Pisanie aplikacji CLI w Go

Wprowadzenie do Go i aplikacji CLI

Go, znany również jako Golang, to język programowania o otwartym kodzie źródłowym zaprojektowany przez Google. Kładzie nacisk na prostotę, bezpieczeństwo i wydajność, dzięki czemu jest doskonałym wyborem do tworzenia aplikacji z interfejsem wiersza poleceń (CLI). Aplikacje CLI to narzędzia, z którymi użytkownicy mogą wchodzić w interakcje za pośrednictwem interfejsu tekstowego, powszechnie używanego do administrowania systemem, automatyzacji i zadań skryptowych. Go dobrze nadaje się do tworzenia aplikacji CLI, ponieważ oferuje

1. Prostotę: Składnia języka Go jest łatwa do zrozumienia i napisania, co pozwala programistom na szybkie tworzenie i utrzymywanie aplikacji CLI.
2. Wydajność: Go jest językiem kompilowanym i statycznie typowanym, co oznacza, że tworzy zoptymalizowane pliki binarne, co skutkuje szybkimi i wydajnymi aplikacjami CLI.
3. Obsługa współbieżności: Go posiada wbudowane prymitywy współbieżności, takie jak goroutines i channels, umożliwiające płynne przetwarzanie równoległe, a ostatecznie szybsze i bardziej responsywne aplikacje CLI.
4. Statyczna kompilacja binarna: Go kompiluje aplikacje do pojedynczego, samodzielnego pliku binarnego - bez zewnętrznych zależności - ułatwiając dystrybucję i wdrażanie aplikacji CLI.
5. Potężna biblioteka standardowa: Standardowa biblioteka Go zapewnia liczne wbudowane pakiety, upraszczając typowe zadania programistyczne CLI, takie jak praca z plikami, tworzenie sieci i obsługa argumentów wiersza poleceń.

W tym artykule poznasz podstawy tworzenia aplikacji CLI przy użyciu Go - od konfigurowania środowiska i struktury aplikacji po obsługę argumentów wiersza poleceń i wykorzystywanie pakietów innych firm.

Pierwsze kroki: Instalacja Go i konfiguracja środowiska

Zanim zaczniesz pisać aplikacje CLI z Go, musisz najpierw zainstalować język programowania Go w swoim systemie.

1. Odwiedź oficjalną stronę pobierania Go, wybierz odpowiedni pakiet binarny dla swojej platformy (Windows, macOS lub Linux) i postępuj zgodnie z instrukcjami instalacji.
2. Po zakończeniu instalacji sprawdź, czy Go jest poprawnie zainstalowany, uruchamiając go version w terminalu. Polecenie to powinno wyświetlić zainstalowaną wersję Go.
3. Skonfiguruj niezbędne zmienne środowiskowe dla Go, w tym GOPATH, która określa lokalizację obszaru roboczego Go (gdzie będą przechowywane projekty i zależności Go) oraz GOROOT, która wskazuje katalog instalacyjny Go.
4. Upewnij się, że polecenie go znajduje się w zmiennej PATH systemu. Pozwala to na wykonywanie poleceń Go z dowolnego katalogu.

Po zainstalowaniu Go i skonfigurowaniu środowiska, możesz rozpocząć tworzenie swojej pierwszej aplikacji CLI.

Struktura aplikacji CLI: Pakiety i moduły

Prawidłowa struktura aplikacji CLI ma zasadnicze znaczenie dla łatwości konserwacji i skalowalności, zapewniając, że kod jest uporządkowany i łatwy w nawigacji. W Go organizację kodu osiąga się za pomocą pakietów i modułów.

Pakiety: Pakiety są sposobem Go na organizowanie i dzielenie kodu. Pakiet składa się z jednego lub więcej plików źródłowych (z rozszerzeniem .go ) znajdujących się w tym samym katalogu. Każdy plik w pakiecie musi zadeklarować nazwę pakietu, określoną słowem kluczowym package na początku pliku. Typowa aplikacja Go CLI ma co najmniej dwa pakiety:

1. main: Jest to domyślny pakiet dla punktu wejścia aplikacji. Jest to miejsce, w którym znajduje się funkcja main( ) i służy jako punkt wyjścia dla aplikacji CLI. Cała logika i polecenia specyficzne dla CLI powinny być umieszczone w pakiecie main.
2. internal lub pkg: Pakiety te zawierają kod wielokrotnego użytku, który jest oddzielony od logiki CLI. Możesz użyć internal dla kodu, który powinien być importowany tylko przez Twój własny kod Go w ramach projektu, a pkg dla kodu, który może być importowany przez dowolny projekt Go.

Moduły: Moduły są sposobem zarządzania zależnościami i wersjami w aplikacjach Go. Wprowadzone w Go 1.11, pozwalają programistom deklarować zależności pakietów i określać wymaganą wersję. Aby utworzyć nowy moduł Go, przejdź do katalogu głównego projektu i wykonaj następujące polecenie:

go mod init your.module.name

To polecenie tworzy plik go.mod w katalogu głównym, który zawiera listę zależności projektu, oraz plik go.sum, który zawiera sumy kontrolne każdej zależności. Podczas importowania pakietów lub korzystania z bibliotek innych firm, Go automatycznie śledzi zależności w plikach go. mod i go.sum.

Źródło obrazu: Język programowania Go

Efektywne korzystanie z pakietów i modułów pozwala zachować czystą i wydajną strukturę kodu aplikacji Go CLI, dzięki czemu łatwiej jest rozwijać, debugować i rozszerzać projekt w przyszłości.

Argumenty i flagi wiersza poleceń

Argumenty wiersza poleceń i flagi są istotnymi składnikami aplikacji CLI, pozwalając użytkownikom kontrolować zachowanie aplikacji i dostarczać niezbędne dane wejściowe. W Go można pracować z argumentami i flagami wiersza poleceń przy użyciu pakietów flag i os . Args biblioteki standardowej.

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

Korzystanie z os.Args

Pakiet os.Args zapewnia bezpośredni dostęp do argumentów wiersza poleceń. Jest to ciąg znaków, gdzie os. Args[0] jest nazwą uruchomionego programu, a pozostałe wpisy reprezentują argumenty przekazane do programu.

Oto przykład użycia os. Args:

package main import ( "fmt" "os" ) func main() { argCount := len(os.Args) fmt.Printf("Liczba argumentów: %d\n", argCount) fmt.Println("Argumenty:", os.Args) }

Po uruchomieniu programu zobaczysz liczbę i listę dostarczonych argumentów.

Korzystanie z pakietu flag

Pakiet flag jest bardziej wyrafinowanym i elastycznym sposobem pracy z flagami wiersza poleceń. Umożliwia definiowanie flag z różnymi typami danych i wygodne analizowanie danych wejściowych.

Poniżej znajduje się przykład użycia pakietu flag:

package main import ( "flag" "fmt" ) func main() { var ( name string age int height float64 ) flag.StringVar(&name, "name", "John Doe", "Your name") flag.IntVar(&age, "age", 21, "Your age") flag.Float64Var(&height, "height", 180.0, "Twój wzrost (w cm)") flag.Parse() fmt.Printf("Name: %s\n", name) fmt.Printf("Age: %d\n", age) fmt.Printf("Height: %.1f\n", height) }

Po zdefiniowaniu flag należy wywołać funkcję flag.Parse (), aby przeanalizować podane dane wejściowe wiersza poleceń i wypełnić zdefiniowane zmienne. Zmiennych tych można następnie używać w całej aplikacji.

Tworzenie poleceń i podpoleceń

W przypadku złożonych aplikacji CLI możesz chcieć utworzyć polecenia i podpolecenia, aby lepiej zorganizować swoje funkcje i opcje. Jednym z popularnych pakietów innych firm do pracy z poleceniami i podpoleceniami w Go jest github.com/spf13/cobra.

Pierwsze kroki z Cobrą

Aby rozpocząć, musisz zainstalować pakiet Cobra:

go get -u github.com/spf13/cobra/cobra

Po zainstalowaniu można utworzyć nową aplikację CLI za pomocą Cobra:

cobra init my-cli --pkg-name=my-cli

To polecenie tworzy nowy katalog o nazwie my-cli z niezbędną strukturą i plikami dla aplikacji CLI opartej na Cobrze.

Definiowanie poleceń

W aplikacji opartej na Cobrze polecenia tworzy się definiując instancje cobra.Command. Każde polecenie ma pole Use (wskazujące, w jaki sposób polecenie jest używane), pole Short (zapewniające krótki opis) i pole Long (zapewniające bardziej szczegółowy opis).

Ponadto każde polecenie powinno mieć pole Run, zawierające funkcję, która wykonuje logikę polecenia. Często definiuje się tę funkcję jako zamknięcie, aby przechwycić flagi i argumenty polecenia.

Oto przykład tworzenia prostego polecenia "greet":

greetCmd := &cobra.Command{ Use: "greet", Short: "Greet someone", Long: "This command greet someone with a customizable message.", Run: func(cmd *cobra.Command, args []string) { // Logic for the greet command }, }

Aby utworzyć polecenie podrzędne, można zdefiniować kolejną instancję cobra.Command i dodać ją jako element podrzędny polecenia nadrzędnego za pomocą metody AddCommand. Na przykład można utworzyć podpolecenie "goodbye" w ramach polecenia "greet":

goodbyeCmd := &cobra.Command{ Use: "goodbye", Short: "Say goodbye to someone", Long: "This subcommand says goodbye to someone in a specific language.", Run: func(cmd *cobra.Command, args []string) { // Logic for the goodbye subcommand }, } greetCmd.AddCommand(goodbyeCmd)

Interaktywne podpowiedzi i dane wejściowe użytkownika

Interaktywne podpowiedzi mogą poprawić wrażenia użytkownika aplikacji CLI, prowadząc użytkowników przez serię pytań i zbierając dane wejściowe na podstawie ich odpowiedzi. Jednym z popularnych pakietów innych firm do pracy z interaktywnymi podpowiedziami w Go jest github.com/AlecAivazis/survey/v2.

Rozpoczęcie pracy z Survey

Najpierw należy zainstalować pakiet Survey:

go get -u github.com/AlecAivazis/survey/v2

Korzystanie z Survey dla interaktywnych podpowiedzi

Survey zapewnia zestaw predefiniowanych typów podpowiedzi, w tym Input, Select, MultiSelect, Confirm i inne. Aby utworzyć monit, należy utworzyć instancję żądanego typu monitu i wywołać funkcję survey.Ask.

package main import ("fmt" "github.com/AlecAivazis/survey/v2" ) func main() { var name string namePrompt := &survey.Input{ Message: "Jak masz na imię?", } err := survey.Ask([]*survey.Question{{ Name:    "name", Prompt: namePrompt, Validate: survey.Required, }}, &name) if err != nil { fmt.Println("Error:", err) return } fmt.Printf("Hello, %s!\n", name) }

Ten fragment kodu demonstruje użycie monitu wejściowego Survey do zebrania nazwy i wyświetlenia wiadomości powitalnej. Pole Validate można ustawić w celu zaimplementowania niestandardowej logiki sprawdzania poprawności danych wprowadzanych przez użytkownika.

Praca z bibliotekami zewnętrznymi

W wielu aplikacjach CLI często polega się na zewnętrznych bibliotekach w celu zwiększenia funkcjonalności i usprawnienia procesu programowania. Go zapewnia nowoczesne i wydajne podejście do zarządzania zależnościami, które umożliwia programistom płynną pracę z zewnętrznymi bibliotekami. Wprowadzone w Go 1.11 moduły Go pozwalają zadeklarować zależności pakietów w projekcie i zautomatyzować proces pobierania, budowania i instalowania wymaganych pakietów. Aby zarządzać zewnętrznymi bibliotekami w aplikacji CLI, wykonaj następujące kroki:

1. Zainicjuj moduł Go: W katalogu głównym aplikacji CLI uruchom polecenie go mod init <nazwa modułu>, zastępując "<nazwa modułu>" żądaną nazwą modułu. Polecenie to utworzy nowy plik o nazwie go. mod w katalogu projektu.
2. Dodawanie zewnętrznych bibliotek: Za każdym razem, gdy chcesz zaimportować zewnętrzną bibliotekę, dodaj niezbędne instrukcje importu w kodzie źródłowym. Przy pierwszym kompilowaniu lub uruchomieniu projektu Go automatycznie pobierze i zainstaluje wymagane wersje tych bibliotek oraz zaktualizuje pliki go.mod i go. sum.
3. Aktualizacja bibliotek: Aby zaktualizować zewnętrzną bibliotekę, można użyć polecenia go get -u, po którym następuje nazwa pakietu. Spowoduje to aktualizację pakietu do najnowszej wersji, odzwierciedlając zmiany w pliku go.mod.
4. Usuwanie nieużywanych bibliotek: Aby usunąć nieużywane biblioteki z pliku go.mod, uruchom polecenie go mod tidy. Spowoduje to usunięcie wszystkich bibliotek, które nie są już potrzebne lub stały się przestarzałe podczas rozwoju.

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

Korzystanie z modułów Go zapewnia kilka korzyści podczas pracy z zewnętrznymi bibliotekami. Na przykład promuje czytelność kodu i upraszcza zarządzanie zależnościami, pozwalając na bardziej łatwą w utrzymaniu i modułową aplikację CLI.

Obsługa błędów i rejestrowanie

Właściwa obsługa błędów i rejestrowanie są kluczowe dla zapewnienia solidności aplikacji CLI. Go oferuje bardzo praktyczne i ergonomiczne podejście do pracy z błędami i logami. Do obsługi błędów w Go można użyć standardowego pakietu errors. Oto kilka najlepszych praktyk podczas pracy z błędami w aplikacjach CLI:

• Zwracaj błędy zamiast paniki: Zamiast powodować panikę i awarię aplikacji, zwracaj błędy z funkcji i odpowiednio je obsługuj. Pozwala to na lepszy przepływ kontroli i mechanizmy odzyskiwania w aplikacji CLI.
• Używaj niestandardowych typów błędów: Twórz własne typy błędów za pomocą funkcji errors.New lub implementując interfejs błędów. Niestandardowe typy błędów umożliwiają przekazywanie bardziej szczegółowych informacji o tym, co poszło nie tak, gdy wystąpi błąd.
• Obsługuj błędy blisko źródła: O ile to możliwe, obsługuj błędy tak blisko ich źródła, jak to tylko możliwe. Pomaga to zachować prostotę kodu i ułatwia rozumowanie obsługi błędów w złożonych sytuacjach.

W przypadku logowania, biblioteka standardowa Go oferuje pakiet log, który zapewnia prosty i elastyczny interfejs logowania. Za pomocą pakietu można rejestrować komunikaty o różnych poziomach ważności i dostosowywać docelowe dane wyjściowe. Aby uzyskać bardziej zaawansowane możliwości rejestrowania, warto rozważyć użycie rejestrowania strukturalnego z popularnym pakietem github.com/sirupsen/logrus. Oto kilka wskazówek dotyczących efektywnego logowania w aplikacji CLI:

• Wybierz odpowiedni poziom logowania: Użyj poziomów rejestrowania, aby rozróżnić błędy krytyczne, ostrzeżenia i zwykłe komunikaty informacyjne. Sprawia to, że dzienniki są bardziej przydatne i pomagają skuteczniej identyfikować problemy.
• Uwzględnianie kontekstu w komunikatach dziennika: Zapewnij odpowiedni kontekst podczas rejestrowania, taki jak wartości zmiennych i nazwy funkcji. Ułatwia to śledzenie problemów podczas rozwiązywania problemów.
• Rozważ logowanie strukturalne: Użyj logowania strukturalnego, aby emitować komunikaty dziennika w formacie nadającym się do odczytu maszynowego, takim jak JSON. Jest to szczególnie przydatne w przypadku scentralizowanych systemów rejestrowania, agregacji dzienników i narzędzi analitycznych.

Testowanie i porównywanie aplikacji CLI

Zapewnienie jakości jest kolejnym istotnym aspektem tworzenia niezawodnych aplikacji CLI. Wbudowana w Go obsługa testowania i porównywania pozwala na pisanie skutecznych testów jednostkowych i mierzenie wydajności aplikacji CLI. Pakiet testowy Go umożliwia pisanie testów jednostkowych, uruchamianie ich równolegle i generowanie raportów pokrycia testami. Użyj następujących technik, aby ulepszyć swoje praktyki testowania:

• Tworzenie funkcji testowych: Napisz funkcje testowe dla komponentów aplikacji CLI i poprzedzaj je przedrostkiem Test, na przykład TestMyFunction. Umieść te funkcje w osobnym pliku _test. go obok testowanego pliku źródłowego.
• Używaj tabel testowych: Stosuj tabele testowe (znane również jako testy oparte na tabelach) do testowania wielu kombinacji wejścia-wyjścia przy użyciu pojedynczej funkcji testowej. Takie podejście upraszcza kod testowy i sprawia, że jest on łatwiejszy w utrzymaniu.
• Uruchamiaj testy równolegle: Wykorzystaj funkcję t.Parallel( ) w swoich funkcjach testowych, aby uruchamiać testy równolegle. Może to przyspieszyć wykonywanie zestawu testów, zwłaszcza w przypadku testów wymagających dużej ilości zasobów.
• Generowanie raportów pokrycia testami: Użyj polecenia go test -cover, aby wygenerować raporty pokrycia kodu. Pomaga to zidentyfikować obszary kodu, które wymagają dokładniejszego testowania i zapewnia wyższy stopień pokrycia testami.

Aby zmierzyć wydajność komponentów aplikacji CLI, Go zapewnia obsługę testów porównawczych za pośrednictwem tego samego pakietu testowego. Z benchmarków można korzystać w następujący sposób:

• Tworzenie funkcji benchmarku: Napisz funkcje benchmarkowe i poprzedzaj je przedrostkiem Benchmark, na przykład BenchmarkMyFunction. Umieść te funkcje w tym samym pliku _test.go zawierającym odpowiednie funkcje testowe.
• Użyj parametru testing.B: Uruchom kod, który chcesz przetestować w pętli kontrolowanej przez parametr testing. B (np. for i := 0; i < b.N; i++ { ... }). Parametr testing . B jest automatycznie dostosowywany przez pakiet testowy w celu uzyskania statystycznie istotnego pomiaru.
• Analiza wyników testów porównawczych: Użyj polecenia go test -bench, aby uruchomić testy porównawcze i przeanalizować wyniki. Może to pomóc w określeniu obszarów aplikacji CLI, które wymagają optymalizacji i oceny wpływu poprawy wydajności.

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

Podsumowując, właściwe zarządzanie zewnętrznymi bibliotekami, obsługa błędów, rejestrowanie, testowanie i analiza porównawcza są niezbędne do tworzenia niezawodnych i wydajnych aplikacji CLI. Wykorzystując różne narzędzia, techniki i najlepsze praktyki opisane w tym artykule, można zapewnić, że aplikacja CLI oparta na Go osiągnie wysoki poziom jakości i doskonałości. Co więcej, połączenie mocy języka Go z wszechstronnymi platformami, takimi jak AppMaster, może znacznie przyspieszyć procesy tworzenia oprogramowania, a tym samym osiągnąć znakomite wyniki.

Wdrażanie i dystrybucja aplikacji CLI

Po zakończeniu tworzenia aplikacji interfejsu wiersza poleceń (CLI) w języku Go, ostatnim krokiem jest jej wdrożenie i dystrybucja, aby użytkownicy mieli do niej dostęp i mogli z niej korzystać. Język programowania Go i jego build toolchain pozwalają na tworzenie samodzielnych, statycznie połączonych plików wykonywalnych, które można łatwo dystrybuować i udostępniać na różnych platformach.

Tworzenie pliku wykonywalnego

Aby zbudować aplikację Go CLI, należy użyć polecenia go build, a następnie docelowego pakietu lub pliku:

go build ./path/to/your/package

Lub:

go build main.go

To polecenie zbuduje wykonywalny plik binarny dla bieżącej platformy (np. Windows, macOS, Linux) i umieści go w bieżącym katalogu roboczym. Domyślnie nazwa pliku binarnego odpowiada nazwie pakietu lub nazwie pliku źródłowego bez rozszerzenia (np. main).

Można jednak określić nazwy wyjściowych plików binarnych i kierować je na różne platformy za pomocą flagi -o i zmiennych środowiskowych:

GOOS=linux GOARCH=amd64 go build -o custom-name ./path/to/your/package

W powyższym przykładzie ustawiliśmy zmienne środowiskowe GOOS i GOARCH, aby poinstruować proces kompilacji Go, aby celował w Linuksa z architekturą AMD64, i ustawiliśmy nazwę wyjściowego pliku binarnego na custom-name.

Kompilacja krzyżowa dla różnych platform

Go upraszcza kompilację krzyżową i można szybko tworzyć pliki wykonywalne dla różnych platform bez skomplikowanych konfiguracji kompilacji. Aby przekompilować aplikację Go CLI na wiele platform, należy odpowiednio ustawić zmienne środowiskowe GOOS i GOARCH. Poniższy przykład pokazuje, jak przekompilować aplikację Go CLI dla systemów Windows, macOS i Linux:

# Dla Windows 64-bit GOOS=windows GOARCH=amd64 go build -o mycli-windows.exe ./path/to/package # Dla macOS 64-bit GOOS=darwin GOARCH=amd64 go build -o mycli-macos ./path/to/package # Dla Linux 64-bit GOOS=linux GOARCH=amd64 go build -o mycli-linux ./path/to/package

Dystrybucja aplikacji CLI

Możesz dystrybuować pliki binarne wykonywalne Go CLI, udostępniając bezpośrednie opcje pobierania na stronie internetowej projektu lub w dokumentacji README. Alternatywą jest dystrybucja jako pakiety specyficzne dla platformy przy użyciu systemów pakowania, repozytoriów lub menedżerów pakietów. Niektóre popularne systemy zarządzania pakietami obejmują:

• Homebrew - menedżer pakietów dla systemów macOS i Linux z przyjazną dla użytkownika składnią do instalowania i zarządzania pakietami.
• APT (systemy oparte na Debianie) - menedżer pakietów dla dystrybucji Linuksa opartych na Debianie, takich jak Ubuntu.
• RPM (systemy oparte na Red Hat) - menedżer pakietów dla dystrybucji Linuksa opartych na Red Hat, takich jak Fedora.

Przemyślenia końcowe i zasoby

Tworzenie potężnych aplikacji CLI za pomocą Go jest przyjemnym i satysfakcjonującym procesem. Prostota, wydajność i zalety dystrybucji binarnej sprawiają, że Go jest idealnym językiem programowania do tego celu. Kontynuując tworzenie aplikacji Go CLI, warto rozważyć zapoznanie się z dodatkowymi zasobami, aby poszerzyć swoją wiedzę i poprawić umiejętności:

• Oficjalna dokumentacja Go - kompleksowy przewodnik po języku programowania Go i jego standardowej bibliotece.
• Go Learning Resources - obszerna lista zasobów edukacyjnych Go, w tym samouczków, książek i kursów.
• Awesome Go - wyselekcjonowana lista pakietów, bibliotek i zasobów Go, podzielona na kategorie tematyczne.
• Go by Example - Praktyczne podejście do Go, zawierające zwięzłe przykłady i wyjaśnienia różnych funkcji Go.

Ponadto warto rozważyć zapoznanie się z platformami no-code, takimi jak AppMaster.io, które wykorzystują Go (golang) jako język programowania zaplecza. AppMaster.io zapewnia intuicyjny interfejs typu " przeciągnij i upuść ", który umożliwia tworzenie aplikacji internetowych, mobilnych i backendowych bez pisania ani jednej linii kodu. Rozumiejąc zarówno Go, jak i platformy no-code, takie jak AppMaster.io, będziesz dobrze przygotowany do tworzenia jeszcze bardziej zaawansowanych rozwiązań programistycznych w przyszłości.