How can I have more than two command line flags control the same behavior?

Question content

In go, I know how to use the github.com/pborman/getopt package to do something like ## Command line parsing of #getopt.

However, this package seems to only support one string version and one rune version of each command line option. Sometimes I want more than just two ways to specify options. For example, for a hypothetical program called

prog, I would like the following code to all perform the exact same function:

prog -r [other args]
prog -r [other args]
prog --recurse [other args]
prog --recursive [other args]

I know I can do the following and test the value of each variable

optrecurse and optrecursive ...

optrecurse   := getopt.boollong("recurse",   'r', "run recursively")
optrecursive := getopt.boollong("recursive", 'r', "run recursively")

Ideally, however, I would like to make a single call providing a value for any of these four possibilities.

I would like something similar to ruby's

optionparser package, with more than two possibilities for any given command line option. Here is a ruby ​​example...

$isRecursive = false
parser = OptionParser.new {
  |opts|
  opts.on('-r', '-R', '--recurse', '--recursive') {
    |arg|
    # All four possibilities are handled with one, single "opts.on" block.
    $isRecursive = true
  }
  # ... etc. ...
}

I'm relatively new to go and it's possible I'm overlooking something while looking for an answer to this question.

Correct answer

In my opinion, there is nothing "weird" about providing more than two ways to specify any given command line option.

The

github.com/clagraff/argparse package I originally mentioned in this "answer" is no longer supported. However, I found a more modern and still supported package that I can use to provide the exact functionality in a manner similar to what is provided in parameter parsing packages for other languages ​​like ruby ​​and python: github.com/tcler/ cmdline -go/cmdline.

Here is a sample program illustrating how it works in go...

package main                  

import (
    "fmt";
    "os";
    "github.com/tcler/cmdline-go/cmdline";
)

func main() {
    var nargv []string = os.args[1:]
    var cli cmdline.cmdline

    var options = []cmdline.option {
        {help: "options:"},
        {names: "r r recurse recursive", argtype: cmdline.n, help: "run recursively"},
    }

    cli = cmdline.parse(options, nargv)

    has_invalid := false
    for _, v := range cli.invalidoptions {
        if !has_invalid {
            fmt.println()
        }
        fmt.println(v)
        has_invalid = true
    }
    if has_invalid {
        fmt.println()
        cmdline.getusage(options)
        os.exit(1)
    }

    recursivemode := cli.getoptionargstring("r")
    fmt.printf("recursive mode: \"%s\"\n", recursivemode)
}

I can run the program the following four ways and it behaves the same in each case...

% go run prog.go -r
% go run prog.go -r
% go run prog.go --recurse
% go run prog.go --recursive

In all four cases it always outputs the following:

recursive mode: "set"

If I run without any options (

which is , just go run prog.go), it outputs the following:

recursive mode: ""

If I run with any other command line arguments, such as

-x, it fails like this:

% go run prog.go -x

option: 'x' undefined

Options:
     -r -R --recurse --recursive
                               Run recursively

[ plus some other "help" text ]

So, now I can write go programs that allow any command line option to be specified in more than two ways.

The above is the detailed content of How can I have more than two command line flags control the same behavior?. For more information, please follow other related articles on the PHP Chinese website!