Reading command line parameters in a Go program can be achieved through the os.Args and flag packages. 1. Use os.Args to directly obtain all parameters, the first element is the program path, which is subsequently input for the user, and the program name can be skipped through os.Args[1:]; 2. For structured parameters such as -name=value, the flag package should be used, which supports binding variables, default values ??and help information. Flag.Parse() should be called to parse and access the value through pointers; 3. When processing subcommands, the value of os.Args[1] can be manually judged and different logic is executed. It is recommended to use the cobra library for complex CLI; 4. In either way, the number of parameters should be checked to avoid panic.

It is actually not difficult to read command line parameters in Go programs, and os package in the standard library can meet basic needs. If you just want to quickly get the parameters passed in during runtime, just use os.Args .

Use os.Args to get parameters

Go's standard library os provides a variable Args , which is a string slice that contains all command line parameters passed in when starting the program. The first element is the path of the program itself, and the following is the parameters you pass.

For example:

 package main

import (
    "fmt"
    "os"
)

func main() {
    args := os.Args
    fmt.Println("all parameters:", args)
}

Run this program and pass the parameters:

 go run main.go foo bar

The output will be:

 All parameters: [/tmp/go-build.../exe/main foo bar]

You can see that the first parameter is the program path, followed by the content you entered. If only the parameters passed by the user are required, you can use os.Args[1:] to skip the program name.

Use flag package to parse the tagged parameters

If you need to deal with structured command line parameters like -name=value or --verbose , it is recommended to use flag package. It supports functions such as binding variables, setting default values, and automatically printing help information.

The basic usage is as follows:

 package main

import (
    "flag"
    "fmt"
)

func main() {
    name := flag.String("name", "world", "please enter a name")
    verbose := flag.Bool("verbose", false, "whether to output detailed information")

    flag.Parse()

    if *verbose {
        fmt.Println("Detailed mode is enabled")
    }
    fmt.Printf("Hello, %s!\n", *name)
}

Operation mode:

 go run main.go -name=Alice -verbose=true

Output:

 Hello, Alice is enabled in detailed mode!

• flag.String creates a string type parameter, and the third parameter is description (help message)
• flag.Parse() must be called to truly parse the parameters
• Parameter values ??can be accessed through pointer dereferences, such as *name

Note: The flag package only supports - starting parameters, not -- . If you have more complex needs, such as supporting double horizontal lines or subcommands, you can consider third-party libraries such as pflag or kingpin .

Process subcommands (such as git add/git commit)

Some tools have multiple subcommands, such as git add and git commit of Git. In this case, flag package is not enough. You can manually determine which command os.Args[1] is, and then do different processing.

Example:

 package main

import (
    "fmt"
    "os"
)

func main() {
    if len(os.Args) < 2 {
        fmt.Println("Please specify the command")
        Return
    }

    switch os.Args[1] {
    case "add":
        fmt.Println("Perform the add operation")
    case "commit":
        fmt.Println("Execute the commit operation")
    default:
        fmt.Println("Unknown Command")
    }
}

This way, you can decide what logic to execute based on the first parameter. If you want to make more complex CLI tools, you can consider using libraries like cobra to organize command structures.

Basically that's it.
Use os.Args for simple scenarios, use flag for structured parameters, and use cobra for complex CLI.
What is not complicated but easy to ignore is: Don't forget to check the number of parameters, otherwise it will be easy to panic.

The above is the detailed content of How to read command line arguments in Go. For more information, please follow other related articles on the PHP Chinese website!