Drapeau de Golang

Les drapeaux de ligne de commande sont une partie importante lors de la création d'applications de ligne de commande. Ils nous permettent de modifier le comportement d'un programme. Par exemple, la commande LS dans Unix nous permet de passer des indicateurs, tels que -l ou -a pour modifier la sortie par défaut.

Cet article vous guidera pour créer, utiliser et analyser les drapeaux de ligne de commande à l'aide du package Flags de la bibliothèque GO Standard.

Importations requises

Pour utiliser et créer des drapeaux à l'aide du package Flags, nous devons les importer. Nous pouvons le faire en utilisant la clause d'importation, comme indiqué ci-dessous:

importer des "drapeaux"

Une fois importé, nous pouvons procéder à l'utiliser.

Déclaration de drapeau de Golang

Le package Flags permet d'effectuer la déclaration de drapeau pour les types de chaîne, entier et booléen. Cette fonctionnalité est fournie par le drapeau.String (), drapeau.Int (), et drapeau.Méthodes bool (), respectivement.

Examinons de près chaque méthode pour mieux comprendre comment les utiliser.

Drapeau.Chaîne()

La méthode de chaîne dans le package d'indicateur vous permet de définir un drapeau de chaîne avec le nom spécifié. La syntaxe de fonction est comme indiqué:

string func (chaîne de nom, chaîne de valeur, chaîne d'utilisation) * chaîne

La fonction prend trois arguments principaux: le nom de l'indicateur, la valeur par défaut et le message d'utilisation.

La fonction renvoie ensuite un pointeur d'adresse vers la variable de chaîne stockant la valeur de l'indicateur.

L'exemple de code suivant montre comment créer un drapeau de chaîne:

package principal
importer (
"drapeau"
"FMT"
)
func main ()
str: = drapeau.String ("nom d'utilisateur", "root", "spécifier le nom d'utilisateur de connexion")

Dans l'exemple de code précédent, nous déclarons un drapeau de la chaîne de type. Nous définissons la valeur par défaut comme «« root »» et une brève description comme troisième paramètre. La fonction renvoie le pointeur de chaîne.

Drapeau.Int ()

La méthode int () est étroitement similaire à la méthode String (). Cependant, nous avons utilisé cette méthode pour déclarer des drapeaux de type int.

Un exemple de code est illustré ci-dessous:

int_flag: = drapeau.Int ("port", 3006, "Spécifiez le port")

Ici, nous déclarons un drapeau int en utilisant le drapeau.Méthode int () avec une valeur par défaut de 3006.

Drapeau.Bool ()

Pour définir un drapeau booléen, nous pouvons utiliser le drapeau.Méthode bool (). Un exemple de code est fourni ci-dessous:

bool_flag: = drapeau.Bool ("exec", true, "Exécuter la commande?")

Analyse du drapeau de Golang

Une fois que tous les drapeaux ont été déclarés, nous utilisons le drapeau.Parse () Méthode. Cela analysera les drapeaux fournis et vous permettra de les utiliser:

drapeau.Parse ()

N'oubliez pas que les drapeaux eux-mêmes sont des pointeurs et ne tiennent pas la valeur réelle. Pour obtenir la valeur, nous devons déréférence avec l'opérateur de déréférence (*).

Un exemple de code source est comme indiqué:

package principal
importer (
"drapeau"
"FMT"
)
func main ()
str: = drapeau.String ("nom d'utilisateur", "root", "spécifier le nom d'utilisateur de connexion")
int_flag: = drapeau.Int ("port", 3006, "Spécifiez le port")
bool_flag: = drapeau.Bool ("exec", true, "Exécuter la commande?")
drapeau.Parse ()
fmt.Println ("str:", * str)
fmt.Println ("int_flag:", * int_flag)
fmt.Println ("bool_flag:", * bool_flag)

Le code précédent doit renvoyer la valeur par défaut des indicateurs spécifiés. Un exemple de sortie est fourni ci-dessous:

str: root
int_flag: 3006
bool_flag: vrai

Golang utilise des drapeaux de ligne de commande

Pour utiliser les drapeaux pour le programme spécifié, il est recommandé de compiler le programme et d'exécuter le programme à l'aide du fichier binaire résultant.

Nous pouvons compiler un programme GO vers un fichier binaire en utilisant la commande build comme:

se construire

Par exemple, pour construire le programme Flags en Go, nous pouvons faire:

aller construire des drapeaux.aller

Cela devrait entraîner un fichier exécutable, que vous pouvez exécuter à partir du terminal.

Pour utiliser les drapeaux définis, nous pouvons exécuter le programme comme:

./drapeau.EXE -UNERNAME = "Developer" -port = 9000 -exec = true

Le programme précédent doit renvoyer une sortie comme indiqué:

STR: développeur
int_flag: 9000
bool_flag: vrai

Pour obtenir de l'aide générée automatiquement, nous pouvons utiliser le drapeau -H. Un exemple est comme indiqué:

./drapeau.exe -h

La commande précédente doit revenir comme:

-exécutif
Exécuter la commande? (par défaut true)
-port int
Spécifiez le port (par défaut 3006)
-chaîne de nom d'utilisateur
Spécifiez le nom d'utilisateur de connexion (par défaut "root")

Si nous spécifions un drapeau qui n'est pas défini dans le programme, le programme renvoie un message d'erreur et affiche le menu d'aide.

Exemple:

./ drapeaux.exe -User = "User"

Le programme doit renvoyer une sortie comme indiqué ci-dessous:

$ ./drapeau.EXE -User = utilisateur
drapeau fourni mais non défini: -Usser
Utilisation de / drapeau.exe:
-exécutif
… . tronqué

Vous pouvez également fournir des arguments de position après les drapeaux. Assurez-vous que les arguments positionnels viennent après un drapeau. Sinon, GO les traitera comme des drapeaux.

Conclusion

Ce fut un tutoriel d'introduction à travailler avec des drapeaux de ligne de commande dans le langage de programmation Go. Nous avons également discuté des différentes méthodes, comme le drapeau.String (), drapeau.Int (), drapeau.Bool (), analyse de drapeau Golang, Golang utilisent des drapeaux de ligne de commande et Golang utilise des drapeaux de ligne de commande. Nous espérons que vous avez trouvé cet article utile. Découvrez d'autres articles sur les conseils Linux pour les conseils et tutoriels GO.