CLI-toepassingen schrijven met Go

Inleiding tot Go en CLI-toepassingen

Go, ook bekend als Golang, is een open-source programmeertaal ontworpen door Google. Het legt de nadruk op eenvoud, veiligheid en prestaties, waardoor het een uitstekende keuze is voor het bouwen van command-line interface (CLI) applicaties. CLI applicaties zijn tools waarmee gebruikers kunnen communiceren via een tekstgebaseerde interface, vaak gebruikt voor systeembeheer, automatisering en scripttaken. Go is zeer geschikt voor CLI ontwikkeling omdat het het volgende biedt:

1. Eenvoud: De syntaxis van Go is eenvoudig te begrijpen en te schrijven, waardoor ontwikkelaars snel CLI-applicaties kunnen bouwen en onderhouden.
2. Prestaties: Go is een gecompileerde en statisch getypeerde taal, wat betekent dat het geoptimaliseerde binaire bestanden produceert, wat resulteert in snelle en efficiënte CLI-toepassingen.
3. Ondersteuning voor gelijktijdigheid: Go heeft ingebouwde concurrency primitieven, zoals goroutines en kanalen, die naadloze parallelle verwerking mogelijk maken en uiteindelijk snellere en responsievere CLI-toepassingen.
4. Statische binaire compilatie: Go compileert toepassingen in een enkele, standalone binary - een zonder externe afhankelijkheden - wat de distributie en implementatie van uw CLI-toepassing vergemakkelijkt.
5. Krachtige standaardbibliotheek: Go's standaardbibliotheek biedt talloze ingebouwde pakketten, die veelvoorkomende CLI-ontwikkelingstaken vereenvoudigen, zoals het werken met bestanden, netwerken en het afhandelen van commandoregelargumenten.

In dit artikel leer je de essentie van het ontwikkelen van CLI applicaties met Go-van het opzetten van je omgeving en het structureren van je applicatie tot het afhandelen van commandoregel argumenten en het gebruik van pakketten van derden.

Aan de slag: Go installeren en je omgeving instellen

Voordat je kunt beginnen met het schrijven van CLI-applicaties met Go, moet je eerst de programmeertaal Go op je systeem installeren.

1. Ga naar de officiële Go downloadpagina, selecteer het juiste binaire pakket voor je platform (Windows, macOS of Linux) en volg de installatie-instructies.
2. Zodra de installatie is voltooid, controleer je of Go correct is geïnstalleerd door go version uit te voeren in je terminal. Dit commando zou de geïnstalleerde Go-versie moeten weergeven.
3. Configureer de benodigde omgevingsvariabelen voor Go, waaronder GOPATH, dat de locatie van je Go-werkruimte bepaalt (waar je Go-projecten en afhankelijkheden worden opgeslagen), en GOROOT, dat naar je Go-installatiemap wijst.
4. Zorg ervoor dat het go commando in de PATH variabele van je systeem staat. Hierdoor kun je Go-commando's vanuit elke map uitvoeren.

Met Go geïnstalleerd en je omgeving geconfigureerd, ben je klaar om te beginnen met het bouwen van je eerste CLI applicatie.

Je CLI-toepassing structureren: Pakketten en modules

Het goed structureren van je CLI applicatie is essentieel voor onderhoudbaarheid en schaalbaarheid, en zorgt ervoor dat je code georganiseerd is en makkelijk te navigeren. In Go wordt code-organisatie bereikt door pakketten en modules.

Pakketten: Packages zijn Go's manier om code te organiseren en op te delen. Een package bestaat uit een of meer bronbestanden (met een .go extensie) die zich in dezelfde map bevinden. Elk bestand in een package moet zijn package naam aangeven, gespecificeerd met het package sleutelwoord aan het begin van het bestand. Een typische Go CLI-toepassing heeft ten minste twee packages:

1. main: Dit is het standaardpakket voor het beginpunt van je applicatie. Het is waar de main() functie zich bevindt en dient als startpunt voor je CLI applicatie. Alle CLI-specifieke logica en commando's moeten in het main package geplaatst worden.
2. internal of pkg: Deze pakketten bevatten herbruikbare code die gescheiden is van je CLI logica. Je kunt internal gebruiken voor code die alleen geïmporteerd mag worden door je eigen Go-code binnen het project, en pkg voor code die geïmporteerd mag worden door elk Go-project.

Modules: Modules zijn een manier om afhankelijkheden en versiebeheer in Go applicaties te beheren. Ze werden geïntroduceerd in Go 1.11 en stellen ontwikkelaars in staat om pakketafhankelijkheden aan te geven en de vereiste versie te specificeren. Om een nieuwe Go-module te maken, navigeer je naar de hoofdmap van je project en voer je het volgende commando uit:

go mod init uw.module.naam

Dit commando maakt een go.mod bestand in de hoofdmap, dat de afhankelijkheden van je project opsomt, en een go.sum bestand, dat de checksums van elke afhankelijkheid bevat. Als je pakketten importeert of bibliotheken van derden gebruikt, houdt Go automatisch de afhankelijkheden bij in de bestanden go.mod en go.sum.

Bron afbeelding: De programmeertaal Go

Door pakketten en modules effectief te gebruiken, kun je een schone en efficiënte codestructuur voor je Go CLI-applicatie behouden, waardoor het eenvoudiger wordt om je project in de toekomst te ontwikkelen, debuggen en uit te breiden.

Commandoregel argumenten en vlaggen

Commandoregelargumenten en vlaggen zijn essentiële onderdelen van CLI-toepassingen, waarmee gebruikers het gedrag van de toepassing kunnen bepalen en noodzakelijke invoer kunnen geven. In Go kun je werken met commandoregelargumenten en vlaggen met behulp van de pakketten flag en os.Args van de standaardbibliotheek.

Try AppMaster no-code today!

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

Start Free

os.Args gebruiken

Het pakket os.Args biedt directe toegang tot de commandoregelargumenten. Het is een slice van strings, waarbij os.Args[0] de naam van het draaiende programma is en de rest van de regels de argumenten weergeven die aan het programma zijn doorgegeven.

Hier is een voorbeeld van het gebruik van os.Args:

package main import ("fmt" "os" ) func main() { argCount := len(os.Args) fmt.Printf("Aantal argumenten: %d\n", argCount) fmt.Println("Argumenten:", os.Args) }

Als je het programma uitvoert, zie je het aantal en de lijst met argumenten.

Het flag pakket gebruiken

Het flag pakket is een meer verfijnde en flexibele manier om met commandoregelvlaggen te werken. Het stelt je in staat om vlaggen met verschillende gegevenstypen te definiëren en de invoer gemakkelijk te parsen.

Hieronder staat een voorbeeld van het gebruik van het flag package:

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, "Uw lengte (in cm)") flag.Parse() fmt.Printf("Naam: %s\n", naam) fmt.Printf("Leeftijd: %d\n", leeftijd) fmt.Printf("Hoogte: %.1f\n", hoogte) }

Zodra je de vlaggen hebt gedefinieerd, roep je flag.Parse() op om de gegeven opdrachtregelinvoer te parseren en de gedefinieerde variabelen te vullen. Je kunt deze variabelen vervolgens in je hele toepassing gebruiken.

Commando's en subcommando's maken

Voor complexe CLI-toepassingen wil je misschien commando's en subcommando's maken om je functionaliteiten en opties beter te organiseren. Een populair pakket van derden voor het werken met commando's en subcommando's in Go is github.com/spf13/cobra.

Aan de slag met Cobra

Om te beginnen moet je het Cobra-pakket installeren:

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

Eenmaal geïnstalleerd, kan je een nieuwe CLI-toepassing maken met Cobra:

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

Dit commando maakt een nieuwe map aan met de naam my-cli met de nodige structuur en bestanden voor een Cobra-gebaseerde CLI-toepassing.

Commando's definiëren

In een Cobra-gebaseerde applicatie maak je commando's door instanties van cobra.Command te definiëren. Elk commando heeft een Use veld (dat aangeeft hoe het commando wordt gebruikt), een Short veld (dat een korte beschrijving geeft) en een Long veld (dat een meer gedetailleerde beschrijving geeft).

Bovendien moet elke opdracht een veld Run hebben, dat een functie bevat die de logica van de opdracht uitvoert. Vaak definieer je deze functie als een afsluiting om de vlaggen en argumenten van de opdracht vast te leggen.

Hier is een voorbeeld van een eenvoudig "begroet" commando:

greetCmd := &cobra.Command{ Gebruik: "greet", Kort: "Begroet iemand", Lang: "Dit commando begroet iemand met een aanpasbaar bericht.", Uitvoeren: func(cmd *cobra.Command, args []string) { // Logica voor het commando begroeten }, }

Om een subcommando te maken, kun je een andere cobra.Command-instantie definiëren en deze toevoegen als kind van het hoofdcommando met de methode AddCommand. Je kunt bijvoorbeeld een subcommando "Vaarwel" maken onder het commando "Groet":

goodbyeCmd := &cobra.Command{ Gebruik: "goodbye", Kort: "Neem afscheid van iemand", Lang: "Dit subcommando neemt afscheid van iemand in een specifieke taal.", Uitvoeren: func(cmd *cobra.Command, args []string) { // Logica voor het subcommando "goodbye" }, } greetCmd.AddCommand(goodbyeCmd)

Interactieve prompts en gebruikersinvoer

Interactieve prompts kunnen de gebruikerservaring van je CLI-toepassing verbeteren door gebruikers door een reeks vragen te leiden en input te verzamelen op basis van hun antwoorden. Een populair pakket van derden voor het werken met interactieve prompts in Go is github.com/AlecAivazis/survey/v2.

Aan de slag met Survey

Eerst moet je het Survey-pakket installeren:

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

Survey gebruiken voor interactieve prompts

Survey biedt een reeks vooraf gedefinieerde prompttypen, waaronder Invoeren, Selecteren, MultiSelect, Bevestigen en meer. Om een prompt te maken, installeer je het gewenste prompttype en roep je de functie survey.Ask op.

package main import ("fmt" "github.com/AlecAivazis/survey/v2" ) func main() { var name string namePrompt := &survey.Input{ Bericht: "Wat is uw naam?", } err := survey.Ask([]*survey.Question{{ Naam:    "naam", Prompt: namePrompt, Validate: survey.Required, }}, &name) if err != nil { fmt.Println("Fout:", err) return } fmt.Printf("Hallo, %s!\n", naam) }

Dit codefragment demonstreert het gebruik van de invoerprompt van Survey om een naam te verzamelen en een begroetingsbericht weer te geven. Het veld Valideren kan worden ingesteld om aangepaste validatielogica voor gebruikersinvoer te implementeren.

Werken met externe bibliotheken

In veel CLI-toepassingen is het gebruikelijk om te vertrouwen op externe bibliotheken om de functionaliteit te verbeteren en het ontwikkelproces te stroomlijnen. Go biedt een moderne en efficiënte benadering van afhankelijkheidsbeheer waarmee ontwikkelaars naadloos met externe bibliotheken kunnen werken. Go-modules, geïntroduceerd in Go 1.11, stellen je in staat om pakketafhankelijkheden aan te geven binnen je project en het proces van downloaden, bouwen en installeren van de benodigde pakketten te automatiseren. Volg deze stappen om externe bibliotheken in je CLI-toepassing te beheren:

1. Initialiseer een Go-module: Voer in de hoofdmap van je CLI-toepassing het commando go mod init <module-naam> uit , waarbij je '<module-naam>' vervangt door de gewenste modulenaam. Deze opdracht maakt een nieuw bestand aan met de naam go.mod in je projectmap.
2. Externe bibliotheken toevoegen: Wanneer je een externe bibliotheek wilt importeren, voeg dan de nodige import-statements toe in je broncode. De eerste keer dat je je project bouwt of uitvoert, zal Go automatisch de vereiste versies van die bibliotheken downloaden en installeren, en de bestanden go.mod en go.sum bijwerken.
3. Bibliotheken bijwerken: Om een externe bibliotheek bij te werken, kun je de opdracht go get -u gevolgd door de pakketnaam gebruiken. Hiermee wordt het pakket bijgewerkt naar de nieuwste versie, waarbij de wijzigingen in uw go.mod-bestand worden weergegeven.
4. Verwijder ongebruikte bibliotheken: Om ongebruikte bibliotheken uit je go.mod bestand te verwijderen, voer je de opdracht go mod tidy uit. Dit verwijdert alle bibliotheken die niet langer nodig zijn of verouderd zijn geraakt tijdens de ontwikkeling.

Try AppMaster no-code today!

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

Start Free

Het gebruik van Go-modules biedt verschillende voordelen bij het werken met externe bibliotheken. Het bevordert bijvoorbeeld de leesbaarheid van de code en vereenvoudigt het beheer van afhankelijkheden, wat zorgt voor een beter onderhoudbare en modulaire CLI-toepassing.

Fouten afhandelen en loggen

Goede foutafhandeling en logging zijn cruciaal om de robuustheid van je CLI-toepassing te garanderen. Go biedt een zeer praktische en ergonomische benadering voor het werken met fouten en logs. Om fouten af te handelen in Go, kun je het standaard fouten pakket gebruiken. Hier zijn enkele best practices voor het werken met fouten in je CLI-toepassingen:

• Retourneer fouten in plaats van paniek: In plaats van je applicatie in paniek te laten raken en te laten crashen, retourneer fouten van functies en behandel ze op de juiste manier. Dit zorgt voor een betere controlestroom en herstelmechanismen in uw CLI-toepassing.
• Gebruik aangepaste fouttypes: Maak uw eigen fouttypes met de functie errors.New of door de error interface te implementeren. Aangepaste fouttypes stellen u in staat om meer specifieke informatie over te brengen over wat er mis ging wanneer er een fout optreedt.
• Handel fouten dicht bij de bron af: Wanneer mogelijk, behandel fouten zo dicht mogelijk bij hun oorsprong. Dit helpt de eenvoud van uw code te behouden en maakt het eenvoudiger om te redeneren over foutafhandeling in complexe situaties.

Om te loggen biedt de Go standaardbibliotheek het logpakket, dat een eenvoudige en flexibele loginterface biedt. Je kunt het pakket gebruiken om berichten met verschillende ernstniveaus te loggen en het uitvoerdoel aan te passen. Voor meer geavanceerde logmogelijkheden kun je overwegen om gestructureerde logging te gebruiken met het populaire github.com/sirupsen/logrus pakket. Hier zijn enkele tips voor effectief loggen in je CLI applicatie:

• Kies het juiste logboekniveau: Gebruik logniveau's om onderscheid te maken tussen kritieke fouten, waarschuwingen en gewone informatieve berichten. Dit maakt logs beter bruikbaar en helpt problemen efficiënter te identificeren.
• Neem context op in logberichten: Geef relevante context bij het loggen, zoals variabele waarden en functienamen. Dit maakt het makkelijker om problemen op te sporen bij het oplossen van problemen.
• Overweeg gestructureerd loggen: Gebruik gestructureerde logging om logberichten uit te zenden in een machineleesbaar formaat zoals JSON. Dit is vooral handig voor gecentraliseerde logsystemen, logaggregatie en analysetools.

CLI-toepassingen testen en benchmarken

Kwaliteitsborging is nog een vitaal aspect van het ontwikkelen van betrouwbare CLI applicaties. Go's ingebouwde ondersteuning voor testen en benchmarken stelt je in staat om effectieve unit tests te schrijven en de prestaties van je CLI applicatie te meten. Met het testpakket van Go kun je unit tests schrijven, ze parallel uitvoeren en testdekkingsrapporten genereren. Gebruik de volgende technieken om je testpraktijken te verbeteren:

• Testfuncties maken: Schrijf testfuncties voor je CLI-applicatiecomponenten en voorzie ze van Test, zoals TestMyFunction. Plaats deze functies in een apart _test.go bestand naast het bronbestand dat wordt getest.
• Gebruik testtabellen: Gebruik testtabellen (ook bekend als tabel-gedreven tests) om meerdere input-output combinaties te testen met behulp van een enkele testfunctie. Deze aanpak vereenvoudigt uw testcode en maakt deze beter onderhoudbaar.
• Voer testen parallel uit: Gebruik de functie t.Parallel() binnen uw testfuncties om tests gelijktijdig uit te voeren. Dit kan de uitvoering van je testsuite versnellen, vooral als je te maken hebt met tests die veel bronnen gebruiken.
• Genereer testdekking rapporten: Gebruik het commando go test -cover om rapporten over de codedekking te genereren. Dit helpt u gebieden van uw code te identificeren die grondiger getest moeten worden en zorgt voor een hogere mate van testdekking.

Om de prestaties van je CLI applicatiecomponenten te meten, biedt Go ondersteuning voor benchmarking via hetzelfde testpakket. Gebruik benchmarks als volgt:

• Maak benchmarkfuncties: Schrijf benchmarkfuncties en geef ze het voorvoegsel Benchmark, zoals BenchmarkMyFunction. Plaats deze functies in hetzelfde _test.go bestand dat de relevante testfuncties bevat.
• Gebruik de parameter testing.B: Voer de code uit die u wilt benchmarken binnen een lus die wordt gecontroleerd door de testing.B parameter (bijvoorbeeld, for i := 0; i < b.N; i++ { ... }). De testing.B parameter wordt automatisch aangepast door het testpakket om een statistisch significante meting te verkrijgen.
• Analyseer de benchmarkresultaten: Gebruik het commando go test -bench om uw benchmarks uit te voeren en de resultaten te analyseren. Dit kan u helpen om gebieden van uw CLI-toepassing te bepalen die geoptimaliseerd moeten worden en om de impact van prestatieverbeteringen te meten.

Try AppMaster no-code today!

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

Start Free

Concluderend, goed beheer van externe bibliotheken, foutafhandeling, loggen, testen en benchmarken zijn van vitaal belang voor het maken van betrouwbare en efficiënte CLI-toepassingen. Door gebruik te maken van de verschillende gereedschappen, technieken en best practices die in dit artikel zijn beschreven, kun je ervoor zorgen dat je Go-gebaseerde CLI applicatie een hoog niveau van kwaliteit en uitmuntendheid bereikt. Daarnaast kan het combineren van de kracht van Go met veelzijdige platforms zoals AppMaster softwareontwikkelingsprocessen enorm versnellen, waardoor uitstekende resultaten worden behaald.

Uw CLI-toepassing implementeren en distribueren

Nadat u de ontwikkeling van uw Command Line Interface (CLI)-toepassing in Go hebt voltooid, is de laatste stap het implementeren en distribueren ervan zodat gebruikers deze kunnen openen en gebruiken. Met de programmeertaal Go en zijn bouwgereedschapskist kun je standalone, statisch gekoppelde uitvoerbare bestanden maken die gemakkelijk te distribueren en te delen zijn op verschillende platforms.

De executable bouwen

Om je Go CLI-toepassing te bouwen, gebruik je het commando go build gevolgd door het doelpakket of -bestand:

go build ./pad/naar/uw/pakket

Of:

go build main.go

Dit commando bouwt een uitvoerbaar binair bestand voor je huidige platform (bijv. Windows, macOS, Linux) en plaatst het in de huidige werkmap. Standaard komt de naam van het binaire bestand overeen met de naam van het pakket of de naam van het bronbestand zonder de extensie (bijvoorbeeld main).

Je kunt echter binaire uitvoerbestandsnamen specificeren en je richten op verschillende platformen met de vlag -o en omgevingsvariabelen:

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

In het bovenstaande voorbeeld stellen we de omgevingsvariabelen GOOS en GOARCH in om het Go bouwproces te instrueren zich te richten op Linux met een AMD64 architectuur en stellen we de binaire bestandsnaam voor de uitvoer in op custom-name.

Cross-compilatie voor verschillende platforms

Go vereenvoudigt cross-compilatie en je kunt snel uitvoerbare bestanden maken voor verschillende platformen zonder complexe bouwconfiguraties. Om je Go CLI applicatie te cross-compileren voor meerdere platformen, stel je de GOOS en GOARCH omgevingsvariabelen overeenkomstig in. Het volgende voorbeeld laat zien hoe je een Go CLI-applicatie cross-compileert voor Windows, macOS en Linux:

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

Uw CLI-toepassing distribueren

U kunt uw Go CLI uitvoerbare binaire bestanden distribueren door directe downloadopties aan te bieden op de website van uw project of in de README documentatie. Als alternatief kunt u distribueren als platform-specifieke pakketten door gebruik te maken van verpakkingssystemen, repositories of package managers. Enkele populaire pakketbeheersystemen zijn

• Homebrew - Een pakketbeheerder voor macOS en Linux met een gebruiksvriendelijke syntaxis voor het installeren en beheren van pakketten.
• APT (Debian-gebaseerde systemen) - Een pakketbeheerder voor Debian-gebaseerde Linux-distributies zoals Ubuntu.
• RPM (Red Hat-gebaseerde systemen) - Een pakketbeheerder voor Red Hat-gebaseerde Linux-distributies zoals Fedora.

Laatste gedachten en bronnen

Het maken van krachtige CLI-toepassingen met Go is een plezierig en lonend proces. De eenvoud, prestaties en binaire distributie voordelen maken Go een ideale programmeertaal voor dit doel. Als je doorgaat met het ontwikkelen van je Go CLI applicaties, overweeg dan om aanvullende bronnen te verkennen om je kennis uit te breiden en je vaardigheden te verbeteren:

• Officiële Go Documentatie - Een uitgebreide gids over de programmeertaal Go en de standaardbibliotheek.
• Go Learning Resources - Een uitgebreide lijst met Go-leermiddelen, waaronder tutorials, boeken en cursussen.
• Awesome Go - Een samengestelde lijst van Go-pakketten, -bibliotheken en -bronnen, ingedeeld op onderwerp.
• Go by Example - Een praktische benadering van Go, met beknopte voorbeelden en uitleg over verschillende Go-functies.

Denk ook eens aan no-code platforms zoals AppMaster.io die Go (golang) als backend programmeertaal gebruiken. AppMaster.io biedt een intuïtieve drag-and-drop interface waarmee je web-, mobiele en backendapplicaties kunt ontwikkelen zonder ook maar één regel code te schrijven. Als je zowel Go als no-code platformen zoals AppMaster.io begrijpt, ben je goed uitgerust om in de toekomst nog geavanceerdere softwareoplossingen te ontwikkelen.