Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
go command line option parser
Go Shell
Branch: master

Merge pull request #144 from shirayu/floatarg

Add tests for negative numeric values using --long=value format
latest commit 1acbbaff2f
@jessevdk authored
Failed to load latest commit information.
examples remove "__complete" command invocation
.travis.yml Updating the go get path for vet and cover
LICENSE Added license
README.md Added coveralls badge
arg.go Improved documentation
arg_test.go Added support for positional arguments
assert_test.go Added assertDiff
check_crosscompile.sh Added darwin and freebsd in checking cross compile
closest.go Use dynamic programming for Levenshtein distance.
command.go Improved documentation
command_private.go Allow specifying parent options after subcommands
command_test.go Allow specifying parent options after subcommands
completion.go Allow remaining arguments consisting of only an option prefix
completion_test.go Implement verbose completion
convert.go Add default, optional values in man page output
convert_test.go Added assertDiff
error.go Fix error type to string
example_test.go Added filename in example
flags.go Allow specifying parent options after subcommands
group.go put Command and Parser objects in the group hierarchy too
group_private.go Optional default values from environment variables
group_test.go implement group namespaces
help.go always check if default values need quotes
help_test.go Add default, optional values in man page output
ini.go Simplify default values
ini_private.go Use newErrorf instead of fmt.Sprintf and newError
ini_test.go Merge pull request #125 from ggilder/add-positional-arg-name-docs
long_test.go Move tests into the flags package
man.go Add default, optional values in man page output
marshal_test.go Make tests work on windows
multitag.go Explicitly check for newline errors in tag values
option.go Add default, optional values in man page output
option_private.go Optional default values from environment variables
options_test.go Move tests into the flags package
optstyle_other.go Reverted the function argumentIsOption
optstyle_windows.go Allow remaining arguments consisting of only an option prefix
parser.go rename Argument to SplitArgument, rename String() to Value(), update …
parser_private.go Allow remaining arguments consisting of only an option prefix
parser_test.go Added tests for a numeric flag like -3
pointer_test.go Move tests into the flags package
short_test.go Make tests work on windows
tag_test.go Run go fmt
termsize.go Added solaris to systems not supporting sysioctl
termsize_linux.go Make TIOCGWINSZ a private const
termsize_nosysioctl.go Added solaris to systems not supporting sysioctl
termsize_other.go Make TIOCGWINSZ a private const
termsize_unix.go Make TIOCGWINSZ a private const
unknown_test.go Move tests into the flags package

README.md

go-flags: a go library for parsing command line arguments

GoDoc Build Status Coverage Status

This library provides similar functionality to the builtin flag library of go, but provides much more functionality and nicer formatting. From the documentation:

Package flags provides an extensive command line option parser. The flags package is similar in functionality to the go builtin flag package but provides more options and uses reflection to provide a convenient and succinct way of specifying command line options.

Supported features:

  • Options with short names (-v)
  • Options with long names (--verbose)
  • Options with and without arguments (bool v.s. other type)
  • Options with optional arguments and default values
  • Multiple option groups each containing a set of options
  • Generate and print well-formatted help message
  • Passing remaining command line arguments after -- (optional)
  • Ignoring unknown command line options (optional)
  • Supports -I/usr/include -I=/usr/include -I /usr/include option argument specification
  • Supports multiple short options -aux
  • Supports all primitive go types (string, int{8..64}, uint{8..64}, float)
  • Supports same option multiple times (can store in slice or last option counts)
  • Supports maps
  • Supports function callbacks
  • Supports namespaces for (nested) option groups

The flags package uses structs, reflection and struct field tags to allow users to specify command line options. This results in very simple and concise specification of your application options. For example:

type Options struct {
    Verbose []bool `short:"v" long:"verbose" description:"Show verbose debug information"`
}

This specifies one option with a short name -v and a long name --verbose. When either -v or --verbose is found on the command line, a 'true' value will be appended to the Verbose field. e.g. when specifying -vvv, the resulting value of Verbose will be {[true, true, true]}.

Example:

var opts struct {
    // Slice of bool will append 'true' each time the option
    // is encountered (can be set multiple times, like -vvv)
    Verbose []bool `short:"v" long:"verbose" description:"Show verbose debug information"`

    // Example of automatic marshalling to desired type (uint)
    Offset uint `long:"offset" description:"Offset"`

    // Example of a callback, called each time the option is found.
    Call func(string) `short:"c" description:"Call phone number"`

    // Example of a required flag
    Name string `short:"n" long:"name" description:"A name" required:"true"`

    // Example of a value name
    File string `short:"f" long:"file" description:"A file" value-name:"FILE"`

    // Example of a pointer
    Ptr *int `short:"p" description:"A pointer to an integer"`

    // Example of a slice of strings
    StringSlice []string `short:"s" description:"A slice of strings"`

    // Example of a slice of pointers
    PtrSlice []*string `long:"ptrslice" description:"A slice of pointers to string"`

    // Example of a map
    IntMap map[string]int `long:"intmap" description:"A map from string to int"`
}

// Callback which will invoke callto:<argument> to call a number.
// Note that this works just on OS X (and probably only with
// Skype) but it shows the idea.
opts.Call = func(num string) {
    cmd := exec.Command("open", "callto:"+num)
    cmd.Start()
    cmd.Process.Release()
}

// Make some fake arguments to parse.
args := []string{
    "-vv",
    "--offset=5",
    "-n", "Me",
    "-p", "3",
    "-s", "hello",
    "-s", "world",
    "--ptrslice", "hello",
    "--ptrslice", "world",
    "--intmap", "a:1",
    "--intmap", "b:5",
    "arg1",
    "arg2",
    "arg3",
}

// Parse flags from `args'. Note that here we use flags.ParseArgs for
// the sake of making a working example. Normally, you would simply use
// flags.Parse(&opts) which uses os.Args
args, err := flags.ParseArgs(&opts, args)

if err != nil {
    panic(err)
    os.Exit(1)
}

fmt.Printf("Verbosity: %v\n", opts.Verbose)
fmt.Printf("Offset: %d\n", opts.Offset)
fmt.Printf("Name: %s\n", opts.Name)
fmt.Printf("Ptr: %d\n", *opts.Ptr)
fmt.Printf("StringSlice: %v\n", opts.StringSlice)
fmt.Printf("PtrSlice: [%v %v]\n", *opts.PtrSlice[0], *opts.PtrSlice[1])
fmt.Printf("IntMap: [a:%v b:%v]\n", opts.IntMap["a"], opts.IntMap["b"])
fmt.Printf("Remaining args: %s\n", strings.Join(args, " "))

// Output: Verbosity: [true true]
// Offset: 5
// Name: Me
// Ptr: 3
// StringSlice: [hello world]
// PtrSlice: [hello world]
// IntMap: [a:1 b:5]
// Remaining args: arg1 arg2 arg3

More information can be found in the godocs: http://godoc.org/github.com/jessevdk/go-flags

Something went wrong with that request. Please try again.