Écrire des applications CLI avec Go

Introduction à Go et aux applications CLI

Go, également connu sous le nom de Golang, est un langage de programmation open-source conçu par Google. Il met l'accent sur la simplicité, la sécurité et les performances, ce qui en fait un excellent choix pour la création d'applications d'interface de ligne de commande (CLI). Les applications CLI sont des outils avec lesquels les utilisateurs peuvent interagir par le biais d'une interface textuelle. Elles sont généralement utilisées pour l'administration du système, l'automatisation et les tâches de script. Go est bien adapté au développement d'interfaces de ligne de commande car il offre les avantages suivants

1. Simplicité : La syntaxe de Go est facile à comprendre et à écrire, ce qui permet aux développeurs de créer et de maintenir rapidement des applications CLI.
2. Performance : Go est un langage compilé et à typage statique, ce qui signifie qu'il produit des fichiers binaires optimisés, d'où des applications CLI rapides et efficaces.
3. Prise en charge de la concurrence : Go intègre des primitives de concurrence, telles que les goroutines et les canaux, qui permettent un traitement parallèle transparent et, en fin de compte, des applications CLI plus rapides et plus réactives.
4. Compilation binaire statique : Go compile les applications en un seul binaire autonome, sans dépendances externes, ce qui facilite la distribution et le déploiement de votre application CLI.
5. Puissante bibliothèque standard : La bibliothèque standard de Go fournit de nombreux paquets intégrés, simplifiant les tâches courantes de développement de l'interface de programmation, telles que l'utilisation de fichiers, la mise en réseau et la gestion des arguments de la ligne de commande.

Dans cet article, vous apprendrez les bases du développement d'applications CLI à l'aide de Go, de la configuration de votre environnement et de la structuration de votre application à la gestion des arguments de ligne de commande et à l'exploitation de paquets tiers.

Pour commencer : Installation de Go et configuration de l'environnement

Avant de commencer à écrire des applications CLI avec Go, vous devez d'abord installer le langage de programmation Go sur votre système.

1. Visitez la page officielle de téléchargement de Go, sélectionnez le paquetage binaire approprié à votre plateforme (Windows, macOS ou Linux) et suivez les instructions d'installation.
2. Une fois l'installation terminée, vérifiez que Go est correctement installé en lançant la commande go version dans votre terminal. Cette commande devrait afficher la version de Go installée.
3. Configurez les variables d'environnement nécessaires pour Go, y compris GOPATH, qui détermine l'emplacement de votre espace de travail Go (où vos projets et dépendances Go seront stockés), et GOROOT, qui pointe vers votre répertoire d'installation Go.
4. Assurez-vous que la commande go figure dans la variable PATH de votre système. Cela vous permet d'exécuter des commandes Go à partir de n'importe quel répertoire.

Une fois Go installé et votre environnement configuré, vous êtes prêt à construire votre première application CLI.

Structurer votre application CLI : Paquets et modules

Il est essentiel de structurer correctement votre application CLI pour en assurer la maintenabilité et l'évolutivité, en veillant à ce que votre code soit organisé et facile à parcourir. En Go, l'organisation du code se fait par le biais de paquets et de modules.

Paquets : Les paquets sont la façon dont Go organise et compartimente le code. Un paquetage consiste en un ou plusieurs fichiers source (avec une extension .go ) situés dans le même répertoire. Chaque fichier d'un paquet doit déclarer son nom de paquet, spécifié avec le mot-clé package au début du fichier. Une application Go CLI typique comporte au moins deux paquets :

1. main: Il s'agit du paquetage par défaut pour le point d'entrée de votre application. C'est là que réside la fonction main() et sert de point de départ à votre application CLI. Toute la logique et les commandes spécifiques à l'ILC doivent être placées dans le paquetage main.
2. internal ou pkg: Ces paquets contiennent du code réutilisable séparé de la logique de l'interface de programmation. Vous pouvez utiliser internal pour le code qui ne doit être importé que par votre propre code Go au sein du projet, et pkg pour le code qui peut être importé par n'importe quel projet Go.

Modules : Les modules sont un moyen de gérer les dépendances et les versions dans les applications Go. Introduits dans Go 1.11, ils permettent aux développeurs de déclarer les dépendances d'un paquetage et de spécifier la version requise. Pour créer un nouveau module Go, accédez au répertoire racine de votre projet et exécutez la commande suivante :

Try AppMaster no-code today!

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

Start Free

go mod init votre.nom.de.module

Cette commande crée un fichier go.mod dans le répertoire racine, qui répertorie les dépendances de votre projet, et un fichier go.sum, qui contient les sommes de contrôle de chaque dépendance. Lorsque vous importez des paquets ou utilisez des bibliothèques tierces, Go garde automatiquement la trace des dépendances dans les fichiers go.mod et go.sum.

Source de l'image : Le langage de programmation Go

En utilisant efficacement les paquets et les modules, vous pouvez maintenir une structure de code propre et efficace pour votre application Go CLI, ce qui facilite le développement, le débogage et l'extension de votre projet à l'avenir.

Arguments et drapeaux de la ligne de commande

Les arguments et les drapeaux de la ligne de commande sont des composants essentiels des applications CLI, qui permettent aux utilisateurs de contrôler le comportement de l'application et de fournir les données nécessaires. En Go, vous pouvez travailler avec les arguments et les drapeaux de la ligne de commande en utilisant les paquets flag et os.Args de la bibliothèque standard.

Utilisation de os.Args

Le paquet os.Args fournit un accès direct aux arguments de la ligne de commande. Il s'agit d'une tranche de chaînes de caractères, où os.Args[0] est le nom du programme en cours d'exécution, et le reste des entrées représente les arguments passés au programme.

Voici un exemple d'utilisation de os.Args:

package main import ("fmt" "os" ) func main() { argCount := len(os.Args) fmt.Printf("Number of arguments : %d\n", argCount) fmt.Println("Arguments :", os.Args) }

En exécutant le programme, vous verrez le nombre et la liste des arguments fournis.

Utilisation du paquetage flag

Le paquetage flag est un moyen plus sophistiqué et plus souple de travailler avec les drapeaux de la ligne de commande. Il vous permet de définir des drapeaux avec différents types de données et d'analyser l'entrée de manière pratique.

Voici un exemple d'utilisation du paquetage 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, "Votre taille (en cm)") flag.Parse() fmt.Printf("Name : %s\n", name) fmt.Printf("Age : %d\n", age) fmt.Printf("Height : %.1f\n", height) }

Une fois les drapeaux définis, vous invoquerez flag.Parse() pour analyser la ligne de commande fournie et remplir les variables définies. Vous pouvez ensuite utiliser ces variables dans votre application.

Création de commandes et de sous-commandes

Pour les applications CLI complexes, vous souhaiterez peut-être créer des commandes et des sous-commandes afin de mieux organiser vos fonctionnalités et vos options. Un paquetage tiers populaire pour travailler avec des commandes et des sous-commandes en Go est github.com/spf13/cobra.

Commencer avec Cobra

Pour commencer, vous devez installer le paquet Cobra :

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

Une fois installé, vous pouvez créer une nouvelle application CLI avec Cobra :

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

Cette commande crée un nouveau répertoire nommé my-cli avec la structure et les fichiers nécessaires pour une application CLI basée sur Cobra.

Définition des commandes

Dans une application basée sur Cobra, vous créez des commandes en définissant des instances de cobra.Command. Chaque commande possède un champ Use (indiquant comment la commande est utilisée), un champ Short (fournissant une courte description), et un champ Long (fournissant une description plus détaillée).

En outre, chaque commande doit avoir un champ Run, contenant une fonction qui exécute la logique de la commande. Vous définirez souvent cette fonction comme une fermeture pour capturer les drapeaux et les arguments de la commande.

Voici un exemple de création d'une simple commande "greet" :

greetCmd := &cobra.Command{ Use : "greet", Short : "Saluer quelqu'un", Long : "Cette commande salue quelqu'un avec un message personnalisable", Run : func(cmd *cobra.Command, args []string) { // Logique de la commande greet }, }

Pour créer une sous-commande, vous pouvez définir une autre instance de cobra.Command et l'ajouter en tant qu'enfant de la commande parent à l'aide de la méthode AddCommand. Par exemple, vous pouvez créer une sous-commande "goodbye" sous la commande "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) { // Logique de la sous-commande goodbye }, } greetCmd.AddCommand(goodbyeCmd)

Invites interactives et saisie de l'utilisateur

Les invites interactives peuvent améliorer l'expérience utilisateur de votre application CLI en guidant les utilisateurs à travers une série de questions et en recueillant des données en fonction de leurs réponses. Un paquetage tiers populaire pour travailler avec des invites interactives en Go est github.com/AlecAivazis/survey/v2.

Try AppMaster no-code today!

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

Start Free

Démarrer avec Survey

Tout d'abord, vous devez installer le paquetage Survey :

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

Utilisation de Survey pour les invites interactives

Survey fournit un ensemble de types d'invites prédéfinies, notamment Input, Select, MultiSelect, Confirm, etc. Pour créer une invite, vous instanciez le type d'invite souhaité et appelez la fonction survey.Ask.

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

Cet extrait de code illustre l'utilisation de l'invite de saisie de l'enquête pour recueillir un nom et afficher un message d'accueil. Le champ Validate peut être défini pour mettre en œuvre une logique de validation personnalisée pour les entrées utilisateur.

Travailler avec des bibliothèques externes

Dans de nombreuses applications CLI, il est courant de s'appuyer sur des bibliothèques externes pour améliorer les fonctionnalités et rationaliser le processus de développement. Go propose une approche moderne et efficace de la gestion des dépendances qui permet aux développeurs de travailler avec des bibliothèques externes de manière transparente. Introduits dans Go 1.11, les modules Go vous permettent de déclarer des dépendances de paquets dans votre projet et d'automatiser le processus de téléchargement, de construction et d'installation des paquets requis. Pour gérer les bibliothèques externes dans votre application CLI, suivez les étapes suivantes :

1. Initialiser un module Go : Dans le répertoire racine de votre application CLI, exécutez la commande go mod init <nom du module>, en remplaçant "<nom du module>" par le nom du module souhaité. Cette commande créera un nouveau fichier nommé go.mod dans le répertoire de votre projet.
2. Ajouter des bibliothèques externes : Lorsque vous souhaitez importer une bibliothèque externe, ajoutez les instructions d'importation nécessaires dans votre code source. La première fois que vous compilerez ou exécuterez votre projet, Go téléchargera et installera automatiquement les versions requises de ces bibliothèques, et mettra à jour les fichiers go.mod et go.sum.
3. Mettre à jour les bibliothèques : Pour mettre à jour une bibliothèque externe, vous pouvez utiliser la commande go get -u suivie du nom du paquetage. Cette commande met à jour le paquetage à la dernière version, en reflétant les changements dans votre fichier go.mod.
4. Supprimer les bibliothèques inutilisées : Pour nettoyer les bibliothèques inutilisées de votre fichier go.mod, exécutez la commande go mod tidy. Cette commande supprime toutes les bibliothèques qui ne sont plus nécessaires ou qui sont devenues obsolètes au cours du développement.

L'utilisation de modules Go présente plusieurs avantages lorsque l'on travaille avec des bibliothèques externes. Par exemple, elle favorise la lisibilité du code et simplifie la gestion des dépendances, ce qui permet d'obtenir une application CLI plus facile à maintenir et plus modulaire.

Gestion des erreurs et journalisation

La gestion des erreurs et la journalisation sont cruciales pour assurer la robustesse de votre application CLI. Go offre une approche très pratique et ergonomique pour travailler avec les erreurs et les journaux. Pour gérer les erreurs en Go, vous pouvez utiliser le paquetage standard errors. Voici quelques bonnes pratiques pour gérer les erreurs dans vos applications CLI :

• Renvoyez des erreurs plutôt que des paniques : Plutôt que de provoquer une panique et un plantage de votre application, renvoyez des erreurs à partir des fonctions et gérez-les de manière appropriée. Cela permet d'améliorer le flux de contrôle et les mécanismes de récupération dans votre application CLI.
• Utilisez des types d'erreur personnalisés : Créez vos propres types d'erreur à l'aide de la fonction errors.New ou en implémentant l'interface error. Les types d'erreur personnalisés vous permettent de transmettre des informations plus spécifiques sur ce qui n'a pas fonctionné lorsqu'une erreur se produit.
• Traitez les erreurs à proximité de la source : Dans la mesure du possible, traitez les erreurs le plus près possible de leur origine. Cela permet de maintenir la simplicité de votre code et facilite le raisonnement sur la gestion des erreurs dans des situations complexes.

Try AppMaster no-code today!

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

Start Free

Pour la journalisation, la bibliothèque standard Go propose le paquetage log, qui fournit une interface de journalisation simple et flexible. Vous pouvez utiliser ce paquetage pour enregistrer des messages avec différents niveaux de gravité et personnaliser la cible de sortie. Pour des capacités de journalisation plus avancées, envisagez d'utiliser la journalisation structurée avec le paquetage populaire github.com/sirupsen/logrus. Voici quelques conseils pour une journalisation efficace dans votre application CLI :

• Choisissez le bon niveau de journalisation : Utilisez les niveaux de journalisation pour différencier les erreurs critiques, les avertissements et les messages d'information ordinaires. Cela rend les journaux plus exploitables et permet d'identifier les problèmes plus efficacement.
• Incluez le contexte dans les messages de journalisation : Fournissez un contexte pertinent lors de la journalisation, tel que les valeurs des variables et les noms des fonctions. Cela facilite le repérage des problèmes lors du dépannage.
• Envisagez la journalisation structurée : Utilisez la journalisation structurée pour émettre des messages de journalisation dans un format lisible par la machine, tel que JSON. Ce format est particulièrement utile pour les systèmes de journalisation centralisés, l'agrégation des journaux et les outils d'analyse.

Test et évaluation comparative des applications CLI

L'assurance qualité est un autre aspect essentiel du développement d'applications CLI fiables. Le support intégré de Go pour les tests et l'analyse comparative vous permet d'écrire des tests unitaires efficaces et de mesurer les performances de votre application CLI. Le paquetage de test de Go vous permet d'écrire des tests unitaires, de les exécuter en parallèle et de générer des rapports sur la couverture des tests. Utilisez les techniques suivantes pour améliorer vos pratiques de test :

• Créer des fonctions de test : Écrivez des fonctions de test pour les composants de votre application CLI et préfixez-les avec Test, comme TestMyFunction. Placez ces fonctions dans un fichier _test.go distinct, à côté du fichier source à tester.
• Utilisez des tables de test : Utilisez des tables de test (également connues sous le nom de tests pilotés par table) pour tester plusieurs combinaisons d'entrées-sorties à l'aide d'une seule fonction de test. Cette approche simplifie votre code de test et le rend plus facile à maintenir.
• Exécutez les tests en parallèle : Utilisez la fonction t.Parallel() dans vos fonctions de test pour exécuter des tests simultanément. Cela peut accélérer l'exécution de votre suite de tests, en particulier lorsqu'il s'agit de tests gourmands en ressources.
• Générer des rapports sur la couverture des tests : Utilisez la commande go test -cover pour générer des rapports sur la couverture du code. Cela vous permet d'identifier les zones de votre code qui nécessitent des tests plus approfondis et de garantir un meilleur niveau de couverture des tests.

Pour mesurer les performances des composants de votre application CLI, Go prend en charge l'analyse comparative par le biais du même package de test. Pour utiliser les tests de performance, procédez comme suit

• Créez des fonctions d'analyse comparative : Écrivez des fonctions de référence et préfixez-les avec Benchmark, comme BenchmarkMyFunction. Placez ces fonctions dans le même fichier _test.go qui contient les fonctions de test correspondantes.
• Utilisez le paramètre testing.B : Exécutez le code que vous souhaitez évaluer à l'intérieur d'une boucle contrôlée par le paramètre testing.B (par exemple, for i := 0 ; i < b.N ; i++ { ... }). Le paramètre testing.B est automatiquement ajusté par le package testing pour obtenir une mesure statistiquement significative.
• Analyser les résultats de l'analyse comparative : Utilisez la commande go test -bench pour exécuter vos tests de référence et analyser les résultats. Cela peut vous aider à déterminer les zones de votre application CLI qui ont besoin d'être optimisées et à évaluer l'impact des améliorations de performance.

En conclusion, une bonne gestion des bibliothèques externes, de la gestion des erreurs, de la journalisation, des tests et de l'évaluation des performances est essentielle pour créer des applications CLI fiables et efficaces. En exploitant les différents outils, techniques et meilleures pratiques décrits dans cet article, vous pouvez vous assurer que votre application CLI basée sur Go atteindra un niveau élevé de qualité et d'excellence. En outre, la combinaison de la puissance de Go avec des plates-formes polyvalentes telles qu'AppMaster peut considérablement accélérer les processus de développement de logiciels, ce qui permet d'obtenir des résultats exceptionnels.

Try AppMaster no-code today!

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

Start Free

Déployer et distribuer votre application CLI

Une fois que vous avez terminé le développement de votre interface de ligne de commande (CLI) en Go, la dernière étape consiste à la déployer et à la distribuer pour que les utilisateurs puissent y accéder et l'utiliser. Le langage de programmation Go et sa chaîne d'outils de construction vous permettent de créer des exécutables autonomes, liés statiquement, qui sont faciles à distribuer et à partager entre les plateformes.

Création de l'exécutable

Pour construire votre application Go CLI, utilisez la commande go build suivie du paquetage ou du fichier cible :

go build ./path/to/your/package

Ou bien :

go build main.go

Cette commande construit un fichier binaire exécutable pour votre plateforme actuelle (par exemple, Windows, macOS, Linux) et le place dans le répertoire de travail actuel. Par défaut, le nom du fichier binaire correspond au nom du paquetage ou au nom du fichier source sans l'extension (par exemple, main).

Cependant, vous pouvez spécifier des noms de fichiers binaires de sortie et cibler différentes plates-formes à l'aide de l'indicateur -o et des variables d'environnement :

GOOS=linux GOARCH=amd64 go build -o nom-personnalisé ./path/to/your/package

Dans l'exemple ci-dessus, nous avons défini les variables d'environnement GOOS et GOARCH pour indiquer au processus de compilation de Go de cibler Linux avec une architecture AMD64, et nous avons défini le nom du fichier binaire de sortie à custom-name.

Compilation croisée pour différentes plateformes

Go simplifie la compilation croisée, et vous pouvez rapidement créer des exécutables pour différentes plateformes sans configuration de compilation complexe. Pour compiler votre application Go CLI pour plusieurs plateformes, définissez les variables d'environnement GOOS et GOARCH en conséquence. L'exemple suivant montre comment compiler une application Go CLI pour Windows, macOS et Linux :

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

Distribuer votre application CLI

Vous pouvez distribuer vos fichiers binaires exécutables Go CLI en fournissant des options de téléchargement direct sur le site Web de votre projet ou dans la documentation README. Vous pouvez également les distribuer sous forme de paquets spécifiques à une plate-forme en utilisant des systèmes de conditionnement, des référentiels ou des gestionnaires de paquets. Parmi les systèmes de gestion de paquets les plus répandus, citons

• Homebrew - Un gestionnaire de paquets pour macOS et Linux avec une syntaxe conviviale pour installer et gérer les paquets.
• APT (systèmes basés sur Debian) - Un gestionnaire de paquets pour les distributions Linux basées sur Debian comme Ubuntu.
• RPM (systèmes basés sur Red Hat) - Un gestionnaire de paquets pour les distributions Linux basées sur Red Hat comme Fedora.

Dernières réflexions et ressources

Créer de puissantes applications CLI avec Go est un processus agréable et gratifiant. La simplicité, les performances et les avantages de la distribution binaire font de Go un langage de programmation idéal. Au fur et à mesure que vous développez vos applications Go CLI, pensez à explorer des ressources supplémentaires pour étendre vos connaissances et améliorer vos compétences :

• Official Go Documentation - Un guide complet sur le langage de programmation Go et sa bibliothèque standard.
• Ressources d'apprentissage Go - Une liste exhaustive de ressources d'apprentissage Go, y compris des tutoriels, des livres et des cours.
• Awesome Go - Une liste de paquets, de bibliothèques et de ressources Go, classés par thème.
• Go by Example - Une approche pratique de Go, avec des exemples concis et des explications sur diverses fonctionnalités de Go.

En outre, vous pouvez explorer les plateformes no-code comme AppMaster.io qui utilisent Go (golang) comme langage de programmation dorsal. AppMaster.io offre une interface intuitive de type "glisser-déposer" qui vous permet de développer des applications web, mobiles et backend sans écrire une seule ligne de code. En comprenant à la fois Go et les plateformes no-code telles que AppMaster.io, vous serez bien équipé pour développer des solutions logicielles encore plus sophistiquées à l'avenir.