How to use CLI in Go?

It is very common to use CLI (Command-Line Interface) in Go language because it allows us to quickly create small, command-line tools and interact with users. This article will detail how to use the CLI in Go and provide some practical tips and advice.

1. CLI Framework

Before we start writing CLI, we need to choose a CLI framework, because these frameworks allow us to quickly create CLI and provide various functions and options . The following are some commonly used Go CLI frameworks:

• Cobra: A very popular and powerful framework that helps us create CLI applications easily and provides various features and options.
• Kingpin: Another popular framework that provides elegant syntax and option parsing.
• Cli: A very simple but useful framework that helps us create small CLI applications.

We can choose the appropriate CLI framework based on the needs and complexity of the project.

2. Creating Commands

Once we have selected the CLI framework, we can start creating commands. Commands are the main component of a CLI application, they define the application's behavior and functionality. Here are some examples of commands:

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

In Cobra, we can create commands using code similar to the following:

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
    },
}

The above code creates a command called "list" , its short description is "List all items" and its long description is "List all items in the given directory".

We can use and modify this framework to easily create commonly used commands and add custom options as needed.

3. Command Options

Command options are optional parameters in the CLI application that can be passed to the command as needed. These options can be created in two ways: using the flag package provided by the framework, or using a third-party library such as pflag or cli.

Here are some examples of command options:

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

In Cobra, we can add options using something like the following code:

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)
}

The above code will add two flags : "all" and "long" and append them to the "list" command.

4. Operation command line parameters

In Go, we can use the os package and flag package to operate command line parameters. The os.Args variable contains the command line arguments passed when running the application. When we use the flag package, we can easily parse and access these parameters.

The following is an example showing how to use the flag package to parse command line parameters:

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)
}

The above code creates two flags: "url" and "timeout", and then parses and uses them.

5. Command Interaction

By interacting with the user, we can create more complex and useful CLI applications. Go has many libraries that can help us achieve interaction, such as cli, term and other libraries.

The following is an example using the cli library:

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)
}

The above code defines a command named "greet", which will output "Hello!" and exit the program. We can add more custom commands and interactions as needed.

6. Testing the CLI Application

Finally, we need to test the CLI application to make sure it works as expected. We can use the testing package in the Go standard library and some third-party tools for testing, such as Testify, GoConvey, etc.

The following is sample test code:

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)
    }
}

The above code tests the command named "list" to ensure that it can display the file list correctly.

Summary

In this article, we covered how to create a CLI application in Go. We learned about the process of selecting a CLI framework, creating commands, using command options, manipulating command line arguments, and interacting with and testing CLI applications. Hope this information is helpful to you and you can implement more useful functions and functions for your CLI application.

The above is the detailed content of How to use CLI in Go?. For more information, please follow other related articles on the PHP Chinese website!