go-flags alternatives and similar packages
Based on the "Standard CLI" category.
Alternatively, view go-flags alternatives based on common mentions on social networks and blogs.
-
The Platinum Searcher
A code search tool similar to ack and the_silver_searcher(ag). It supports multi platforms and multi encodings. -
readline
A pure golang implementation that provide most of features in GNU-Readline under MIT license. -
pflag
Drop-in replacement for Go's flag package, implementing POSIX/GNU-style --flags. -
mitchellh/cli
A Go library for implementing command-line interfaces. -
cli-init
The easy way to start building Golang command line application. -
mow.cli
A Go library for building CLI applications with sophisticated flag and argument parsing and validation. -
flaggy
A robust and idiomatic flags package with excellent subcommand support. -
argparse
Command line argument parser inspired by Python's argparse module. -
commandeer
Dev-friendly CLI apps: sets up flags, defaults, and usage based on struct fields and tags. -
sflags
Struct based flags generator for flag, urfave/cli, pflag, cobra, kingpin and other libraries. -
wmenu
An easy to use menu structure for cli applications that prompts users to make choices. -
1build
Command line tool to frictionlessly manage project-specific commands. -
flag
A simple but powerful command line option parsing library for Go support subcommand -
wlog
A simple logging interface that supports cross-platform color and concurrency. -
go-getoptions
Go option parser inspired on the flexibility of Perl’s GetOpt::Long. -
argv
A Go library to split command line string as arguments array using the bash syntax. -
flagvar
A collection of flag argument types for Go's standard flag package. -
Go-Console
GoConsole allows you to create butifull command-line commands with arguments and options. (follow the docopt standard) -
hiboot cli
cli application framework with auto configuration and dependency injection.
Scout APM - Leading-edge performance monitoring starting at $39/month
Do you think we are missing an alternative of go-flags or a related project?
README
go-flags: a go library for parsing command line arguments
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 flag restricted to a pre-defined set of strings
Animal string `long:"animal" choice:"cat" choice:"dog"`
// 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",
"--animal", "dog", // anything other than "cat" or "dog" will raise an error
"-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)
}
fmt.Printf("Verbosity: %v\n", opts.Verbose)
fmt.Printf("Offset: %d\n", opts.Offset)
fmt.Printf("Name: %s\n", opts.Name)
fmt.Printf("Animal: %s\n", opts.Animal)
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