Ontwikkel een CLI-tool in Go met argumenten en flags
description
Met deze prompt leer je effectief een CLI-tool te ontwikkelen in Go, wat handig is voor automatisering en het bouwen van tools voor ontwikkelaars. Je krijgt inzicht in argument parsing zonder externe afhankelijkheden, wat zorgt voor overzichtelijke en onderhoudbare code.
prompt
Help me een command-line interface (CLI) tool te maken in Go die argumenten en flags accepteert om verschillende functionaliteiten aan te sturen. Beschrijf hoe ik de ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! In Go kun je de standaardbibliotheek `flag` gebruiken om command-line argumenten en flags te parseren. Hier is een eenvoudige uitleg en een voorbeeld van een CLI-tool die gebruikers begroet op basis van hun naam via een vlag.
### Stappen om te beginnen:
1. Importeer de `flag` package.
2. Definieer flags met `flag.String`, `flag.Int`, etc.
3. Roep `flag.Parse()` aan om de vlaggen te parsen.
4. Gebruik de geparsete vlagwaarden in je programma.
### Voorbeeld: Een eenvoudige CLI-tool die de gebruiker begroet
```go
package main
import (
"flag"
"fmt"
)
func main() {
// Definieer een vlag voor de naam
naam := flag.String("naam", "wereld", "De naam van de persoon die je wilt begroeten")
// Parseer de vlaggen
flag.Parse()
// Gebruik de waarde van de vlag
fmt.Printf("Hallo, %s!\n", *naam)
}
```
### Uitleg:
- `flag.String()` maakt een nieuwe string-vlag met de naam `-naam`, een standaardwaarde `"wereld"` en een beschrijving.
- Na `flag.Parse()` bevat de variabele `naam` een pointer naar de waarde van de vlag.
- Om de waarde te gebruiken, moet je de pointer dereferencen met `*naam`.
### Hoe te gebruiken:
- Compileer de code: `go build begroet.go`
- Voer uit met een vlag:
```
./begroet -naam=Jan
```
Dit geeft:
```
Hallo, Jan!
```
- Als je geen vlag opgeeft, wordt de standaardwaarde gebruikt:
```
./begroet
```
Resultaat:
```
Hallo, wereld!
```
Met deze basis kun je meer flags toevoegen en je CLI-tool uitbreiden voor complexere functionaliteiten!
provider: deepseek
model: deepseek-chat
Gebruik de `flag` package uit Go's standaardbibliotheek voor argument parsing. Hier is een complete implementatie:
```go
package main
import (
"flag"
"fmt"
"os"
)
func main() {
// Definieer flags
name := flag.String("name", "gebruiker", "Jouw naam voor de begroeting")
help := flag.Bool("help", false, "Toon help informatie")
// Parse de command-line arguments
flag.Parse()
// Help functionaliteit
if *help {
flag.Usage()
os.Exit(0)
}
// Begroet de gebruiker
fmt.Printf("Hallo, %s!\n", *name)
}
```
**Gebruik:**
1. **Compileer de tool:**
```bash
go build -o greet
```
2. **Voorbeelden van gebruik:**
```bash
# Standaard begroeting
./greet
# Output: Hallo, gebruiker!
# Met naam flag
./greet -name "Jan"
# Output: Hallo, Jan!
# Help informatie
./greet -help
```
**Belangrijke concepten:**
- `flag.String()`: Definieert een string flag met default waarde en beschrijving
- `flag.Bool()`: Definieert een boolean flag
- `flag.Parse()`: Verwerkt de command-line arguments
- `flag.Usage()`: Toont automatisch gegenereerde help informatie
**Alternatieve syntax:**
```bash
# Lange vorm
./greet --name "Maria"
# Korte vorm (als je short flags definieert)
// name := flag.String("n", "gebruiker", "Jouw naam")
// ./greet -n "Piet"
```
De `flag` package zorgt automatisch voor:
- Type conversie en validatie
- Help tekst generatie
- Error handling voor ongeldige flags
- Ondersteuning voor zowel `-flag` als `--flag` syntax