Le Go par l'exemple: Options de ligne de commande

Les options de ligne de commande sont une manière courante de préciser des options pour des programmes en ligne de commande. Par exemple, dans wc -l, le -l est une option.

 
package main

Go fournit un package flag qui permet d’analyser des options simples. Nous utiliserons ce package pour implémenter notre programme d’exemple.

 
import "flag"
import "fmt"

func main() {

Des déclarations d’options simples sont disponibles pour les string, les entiers et les booléens. Ici on déclare une option word avec comme valeur par défaut "foo", et une courte description. La fonction flag.String renvoie un pointeur sur la chaîne (pas une chaîne directement). Nous verrons comment utliser ce pointeur après.

 
    wordPtr := flag.String("word", "foo", "une chaine")

On déclare des options numb et fork, en utilisant une approche similaire.

 
    numbPtr := flag.Int("numb", 42, "un int")
    boolPtr := flag.Bool("fork", false, "un booleen")

Il est également possible de déclarer l’option en utilisant une variable déjà déclarée ailleurs dans le programme. A noter que l’on doit passer un pointeur à la fonction de déclaration d’option.

 
    var svar string
    flag.StringVar(&svar, "svar", "bar", "a string var")

Une fois que toutes les options sont déclarées, il faut appeller flag.Parse() pour exécuter l’analyse des paramètres de ligne de commande.

 
    flag.Parse()

Ici, on va afficher les options analysées ainsi que les éventuels paramètres restants. A noter qu’il faut déréférencer les pointeurs, par ex. avec *wordPtr pour obtenir la véritable valeur des options.

 
    fmt.Println("word:", *wordPtr)
    fmt.Println("numb:", *numbPtr)
    fmt.Println("fork:", *boolPtr)
    fmt.Println("svar:", svar)
    fmt.Println("tail:", flag.Args())
}

Pour expérimenter le programme de test d’options de

 
#ligne de commande, le plus simple est de le compiler

puis d’exécuter le binaire ensuite.

 
$ go build command-line-flags.go

Essayer le programme en donnant tout d’abord des valeurs pour toutes les options.

 
$ ./command-line-flags -word=opt -numb=7 -fork -svar=flag
word: opt
numb: 7
fork: true
svar: flag
tail: []

Notez que si vous ne précisez pas certaines options, elles prennent automatiquement leurs valeurs par défaut.

 
$ ./command-line-flags -word=opt
word: opt
numb: 42
fork: false
svar: bar
tail: []

Des arguments restants peuvent être fournis après toutes les options

 
$ ./command-line-flags -word=opt a1 a2 a3
word: opt
...
tail: [a1 a2 a3]

Notez que le package flag a besoin que toutes les options apparaissent avant les arguments ‘positionnels’. Sinon, les options sont traités comme des arguments positionnels.

 
$ ./command-line-flags -word=opt a1 a2 a3 -numb=7
word: opt
numb: 42
fork: false
svar: bar
tail: [a1 a2 a3 -numb=7]

Utiliseez les options -h ou --help pour obtenir une aide générée automatiquement au sujet des paramètres de ligne de commande.

 
$ ./command-line-flags -h
Usage of ./command-line-flags:
  -fork=false: a bool
  -numb=42: an int
  -svar="bar": a string var
  -word="foo": a string

Si vous fournissez une option qui n’était pas précisée au package flag, le programme affichera un message d’erreur puis le texte d’aide à nouveau.

 
$ ./command-line-flags -wat
flag provided but not defined: -wat
Usage of ./command-line-flags:
...

Ensuite nous allons regarder les variables d’environnement, une autre manière courante de paramètrer les programmes.

Exemple suivant: Variables d'environnement.

par @clemkeirua de KeiruaProd | retours | source | license