Comment utiliser la CLI dans Go ?

Il est très courant d'utiliser CLI (Command-Line Interface) dans le langage Go car cela nous permet de créer rapidement de petits outils en ligne de commande et d'interagir avec les utilisateurs. Cet article détaillera comment utiliser la CLI dans Go et fournira quelques astuces et conseils pratiques.

1. CLI framework

Avant de commencer à écrire des CLI, nous devons choisir un framework CLI, car ces frameworks nous permettent de créer rapidement des CLI, et offre diverses fonctionnalités et options. Voici quelques frameworks Go CLI couramment utilisés :

• Cobra : Un framework très populaire et puissant qui nous aide à créer facilement des applications CLI et fournit diverses fonctionnalités et options.
• Kingpin : Un autre framework populaire qui fournit une syntaxe élégante et une analyse d'options.
• Cli : Un framework très simple mais utile qui nous aide à créer de petites applications CLI.

Nous pouvons choisir le framework CLI approprié en fonction des besoins et de la complexité du projet.

2. Création de commandes

Une fois que nous avons sélectionné le framework CLI, nous pouvons commencer à créer des commandes. Les commandes sont le composant principal d'une application CLI, elles définissent le comportement et les fonctionnalités de l'application. Voici quelques exemples de commandes :

$ mycli ls
$ mycli mkdir /path/to/directory
$ mycli cat /path/to/file.txt

Dans Cobra, nous pouvons utiliser un code similaire au suivant pour créer des commandes :

var listCmd = &cobra.Command{
    Use:   "list",
    Short: "List all the items",
    Long:  `List all the items in a given directory`,
    Run: func(cmd *cobra.Command, args []string) {
        // command logic goes here
    },
}

Le code ci-dessus crée une commande appelée "list" commande, sa description courte est « Liste de tous les éléments » et sa description longue est « Liste de tous les éléments du répertoire donné. »

Nous pouvons utiliser et modifier ce framework pour créer facilement des commandes couramment utilisées et ajouter des options personnalisées si nécessaire.

3. Options de commande

Les options de commande sont des paramètres facultatifs dans l'application CLI qui peuvent être transmis à la commande selon les besoins. Ces options peuvent être créées de deux manières : en utilisant le package flag fourni par le framework, ou en utilisant une bibliothèque tierce telle que pflag ou cli.

Voici quelques exemples d'options de commande :

$ mycli list -a -l
$ mycli cat /path/to/file --verbose=false

Dans Cobra, nous pouvons ajouter des options en utilisant quelque chose comme le code suivant :

var listCmd = &cobra.Command{
    Use:   "list",
    Short: "List all the items",
    Long:  `List all the items in a given directory`,
    Run: func(cmd *cobra.Command, args []string) {
        // command logic goes here
    },
}

func init() {
    listCmd.PersistentFlags().BoolVarP(&showAll, "all", "a", false, "Show all files")
    listCmd.PersistentFlags().BoolVarP(&longFormat, "long", "l", false, "Use long listing format")
    rootCmd.AddCommand(listCmd)
}

Above The le code ajoutera deux indicateurs : "all" et "long", puis les ajoutera à la commande "list".

4. Paramètres de ligne de commande d'opération

Dans Go, nous pouvons utiliser le package os et le package flag pour faire fonctionner les paramètres de ligne de commande. La variable os.Args contient les arguments de ligne de commande transmis lors de l'exécution de l'application. Lorsque nous utilisons le package flag, nous pouvons facilement analyser et accéder à ces paramètres.

Ce qui suit est un exemple montrant comment utiliser le package flag pour analyser les paramètres de ligne de commande :

func main() {
    // Define flags
    url := flag.String("url", "https://www.example.com", "URL to fetch")
    timeout := flag.Duration("timeout", time.Second * 5, "Timeout for HTTP request")

    flag.Parse()

    // Use flags
    fmt.Printf("Fetching %s with timeout %v...", *url, *timeout)
}

Le code ci-dessus crée deux indicateurs : "url" et "timeout", puis les analyse et les utilise.

5. Command Interaction

En interagissant avec l'utilisateur, nous pouvons créer des applications CLI plus complexes et plus utiles. Go possède de nombreuses bibliothèques qui peuvent nous aider à réaliser une interaction, telles que les bibliothèques cli, term et autres.

Ce qui suit est un exemple d'utilisation de la bibliothèque cli :

func main() {
    app := cli.NewApp()
    app.Name = "myapp"
    app.Usage = "An example CLI application"

    // Define commands
    app.Commands = []cli.Command{
        {
            Name:    "greet",
            Aliases: []string{"g"},
            Usage:   "Greet the user",
            Action: func(c *cli.Context) error {
                fmt.Println("Hello!")
                return nil
            },
        },
        // Add more commands here
    }

    app.Run(os.Args)
}

Le code ci-dessus définit une commande nommée "greet", qui affichera "Bonjour" et quittera le programme ! . Nous pouvons ajouter plus de commandes et d'interactions personnalisées si nécessaire.

6. Test de l'application CLI

Enfin, nous devons tester l'application CLI pour nous assurer qu'elle fonctionne comme prévu. Nous pouvons utiliser le package de test dans la bibliothèque standard Go et certains outils tiers pour les tests, tels que Testify, GoConvey, etc.

Voici un exemple de code de test :

func TestListCmd(t *testing.T) {
    cmd := exec.Command("mycli", "list", "-a", "-l")
    bytes, err := cmd.CombinedOutput()
    output := string(bytes)
    if err != nil {
        t.Errorf("Command failed: %v", err)
    }
    if !strings.Contains(output, "testFile") {
        t.Errorf("Expected output to contain 'testFile', got '%s'", output)
    }
}

Le code ci-dessus teste la commande nommée "list" pour s'assurer qu'elle peut afficher correctement la liste des fichiers.

Résumé

Dans cet article, nous avons expliqué comment créer une application CLI dans Go. Nous avons découvert le processus de sélection d'un framework CLI, de création de commandes, d'utilisation des options de commande, de manipulation des arguments de ligne de commande, ainsi que d'interaction et de test des applications CLI. J'espère que ces informations vous seront utiles et que vous pourrez implémenter des fonctions et des fonctions plus utiles pour votre application CLI.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!