golang 几个好用的cli package
cli 开发在golang 的软件开发中占用很大，同时开源的比较好用的cli也很多，以下是整理的几个cli
github.com/spf13/cobra
这个比较有名了， 好多框架都使用了这个
以下是一个简单的使用
- 代码
package main
import (
"github.com/spf13/cobra"
)
func main() {
cmd := newCommand()
cmd.AddCommand(newNestedCommand())
rootCmd := &cobra.Command{}
rootCmd.AddCommand(cmd)
if err := rootCmd.Execute(); err != nil {
println(err.Error())
}
}
func newCommand() *cobra.Command {
cmd := &cobra.Command{
Run: func(cmd *cobra.Command, args []string) {
println(`Foo`)
},
Use: `foo`,
Short: "Command foo",
Long: "This is a command",
}
return cmd
}
func newNestedCommand() *cobra.Command {
cmd := &cobra.Command{
Run: func(cmd *cobra.Command, args []string) {
println(`Bar`)
},
Use: `bar`,
Short: "Command bar",
Long: "This is a nested command",
}
return cmd
}
- 效果
go run main.go
Usage:
[command]
Available Commands:
foo Command foo
help Help about any command
Flags:
-h, --help help for this command
Use " [command] --help" for more information about a command.
github.com/urfave/cli
这个也比较有名，好多框架也使用了这个
- 代码
package main
import (
"log"
"os"
"sort"
"github.com/urfave/cli"
)
func main() {
app := cli.NewApp()
app.Flags = []cli.Flag{
cli.StringFlag{
Name: "lang, l",
Value: "english",
Usage: "Language for the greeting",
},
cli.StringFlag{
Name: "config, c",
Usage: "Load configuration from `FILE`",
},
}
app.Commands = []cli.Command{
{
Name: "complete",
Aliases: []string{"c"},
Usage: "complete a task on the list",
Action: func(c *cli.Context) error {
log.Print("ddd")
return nil
},
},
{
Name: "add",
Aliases: []string{"a"},
Usage: "add a task to the list",
Action: func(c *cli.Context) error {
return nil
},
},
}
sort.Sort(cli.FlagsByName(app.Flags))
sort.Sort(cli.CommandsByName(app.Commands))
err := app.Run(os.Args)
if err != nil {
log.Fatal(err)
}
}
- 运行效果
go run cmd/cli/main.go
NAME:
main - A new cli application
USAGE:
main [global options] command [command options] [arguments
VERSION:
0.0.0
COMMANDS:
add, a add a task to the list
complete, c complete a task on the list
help, h Shows a list of commands or help for one command
GLOBAL OPTIONS:
--config FILE, -c FILE Load configuration from FILE
--lang value, -l value Language for the greeting (default: "english")
--help, -h show help
--version, -v print the version
github.com/google/subcommands
- 代码
package main
import (
"context"
"flag"
"fmt"
"os"
"strings"
"github.com/google/subcommands"
)
type printCmd struct {
capitalize bool
}
func (*printCmd) Name() string { return "print" }
func (*printCmd) Synopsis() string { return "Print args to stdout." }
func (*printCmd) Usage() string {
return `print [-capitalize] <some text>:
Print args to stdout.
`
}
func (p *printCmd) SetFlags(f *flag.FlagSet) {
f.BoolVar(&p.capitalize, "capitalize", false, "capitalize output")
}
func (p *printCmd) Execute(_ context.Context, f *flag.FlagSet, _
for _, arg := range f.Args() {
if p.capitalize {
arg = strings.ToUpper(arg)
}
fmt.Printf("%s ", arg)
}
fmt.Println()
return subcommands.ExitSuccess
}
func main() {
subcommands.Register(subcommands.HelpCommand(), "")
subcommands.Register(subcommands.FlagsCommand(), "")
subcommands.Register(subcommands.CommandsCommand(), "")
subcommands.Register(&printCmd{}, "")
flag.Parse()
ctx := context.Background()
os.Exit(int(subcommands.Execute(ctx)))
}
- 效果
go run cmd/subcommands/main.go
Usage: main <flags> <subcommand> <subcommand args>
Subcommands:
commands list all command names
flags describe all known top-level flags
help describe subcommands and their syntax
print Print args to stdout.
Use "main flags" for a list of top-level flags
exit status 2
github.com/mitchellh/cli
这个是hashicorp 好多产品使用的一个cli
- 代码
package main
import (
"fmt"
"log"
"os"
"github.com/mitchellh/cli"
)
func fooCommandFactory() (cli.Command, error) {
return new(FooCommand), nil
}
func barCommandFactory() (cli.Command, error) {
return new(BarCommand), nil
}
// FooCommand fooCommand
type FooCommand struct{}
// Help should return long-form help text that includes the command-line
// usage, a brief few sentences explaining the function of the command,
// and the complete list of flags the command accepts.
func (f *FooCommand) Help() string {
return "help foo"
}
// Run should run the actual command with the given CLI instance and
// command-line arguments. It should return the exit status when it is
// finished.
//
// There are a handful of special exit codes this can return documented
// above that change behavior.
func (f *FooCommand) Run(args []string) int {
fmt.Println("Foo Command is running")
return 1
}
// Synopsis should return a one-line, short synopsis of the command.
// This should be less than 50 characters ideally.
func (f *FooCommand) Synopsis() string {
return "foo command Synopsis"
}
// BarCommand barCommand
type BarCommand struct{}
// Help should return long-form help text that includes the command-line
// usage, a brief few sentences explaining the function of the command,
// and the complete list of flags the command accepts.
func (b *BarCommand) Help() string {
return "help bar"
}
// Run should run the actual command with the given CLI instance and
// command-line arguments. It should return the exit status when it is
// finished.
//
// There are a handful of special exit codes this can return documented
// above that change behavior.
func (b *BarCommand) Run(args []string) int {
fmt.Println("bar Command is running")
return 1
}
// Synopsis should return a one-line, short synopsis of the command.
// This should be less than 50 characters ideally.
func (b *BarCommand) Synopsis() string {
return "bar command Synopsis"
}
func main() {
c := cli.NewCLI("app", "1.0.0")
c.Args = os.Args[1:]
c.Commands = map[string]cli.CommandFactory{
"foo": fooCommandFactory,
"bar": barCommandFactory,
}
exitStatus, err := c.Run()
if err != nil {
log.Println(err)
}
os.Exit(exitStatus)
}
- 运行效果
go run cmd/hashicorp-cli/main.go
Usage: app [--version] [--help] <command> [<args>]
Available commands are:
bar bar command Synopsis
foo foo command Synopsis
github.com/alecthomas/kingpin
这个cli pacakge 也是大家用的比较多的一个
- 代码
package main
import (
"fmt"
"os"
"gopkg.in/alecthomas/kingpin.v2"
)
func listHosts() []string {
// Provide a dynamic list of hosts from a hosts file or otherwise
// for bash completion. In this example we simply return static slice.
// You could use this functionality to reach into a hosts file to provide
// completion for a list of known hosts.
return []string{"sshhost.example", "webhost.example", "ftphost.example"}
}
type NetcatCommand struct {
hostName string
port int
format string
}
func (n *NetcatCommand) run(c *kingpin.ParseContext) error {
fmt.Printf("Would have run netcat to hostname %v, port %d, and output format %v\n", n.hostName, n.port, n.format)
return nil
}
func configureNetcatCommand(app *kingpin.Application) {
c := &NetcatCommand{}
nc := app.Command("nc", "Connect to a Host").Action(c.run)
nc.Flag("nop-flag", "Example of a flag with no options").Bool()
// You can provide hint options using a function to generate them
nc.Flag("host", "Provide a hostname to nc").
Required().
HintAction(listHosts).
StringVar(&c.hostName)
// You can provide hint options statically
nc.Flag("port", "Provide a port to connect to").
Required().
HintOptions("80", "443", "8080").
IntVar(&c.port)
// Enum/EnumVar options will be turned into completion options automatically
nc.Flag("format", "Define the output format").
Default("raw").
EnumVar(&c.format, "raw", "json")
// You can combine HintOptions with HintAction too
nc.Flag("host-with-multi", "Define a hostname").
HintAction(listHosts).
HintOptions("myhost.com").
String()
// And combine with themselves
nc.Flag("host-with-multi-options", "Define a hostname").
HintOptions("myhost.com").
HintOptions("myhost2.com").
String()
// If you specify HintOptions/HintActions for Enum/EnumVar, the options
// provided for Enum/EnumVar will be overridden.
nc.Flag("format-with-override-1", "Define a format").
HintAction(listHosts).
Enum("option1", "option2")
nc.Flag("format-with-override-2", "Define a format").
HintOptions("myhost.com", "myhost2.com").
Enum("option1", "option2")
}
func addSubCommand(app *kingpin.Application, name string, description string) {
c := app.Command(name, description).Action(func(c *kingpin.ParseContext) error {
fmt.Printf("Would have run command %s.\n", name)
return nil
})
c.Flag("nop-flag", "Example of a flag with no options").Bool()
}
func main() {
app := kingpin.New("completion", "My application with bash completion.")
app.Flag("flag-1", "").String()
app.Flag("flag-2", "").HintOptions("opt1", "opt2").String()
configureNetcatCommand(app)
// Add some additional top level commands
addSubCommand(app, "ls", "Additional top level command to show command completion")
addSubCommand(app, "ping", "Additional top level command to show command completion")
addSubCommand(app, "nmap", "Additional top level command to show command completion")
kingpin.MustParse(app.Parse(os.Args[1:]))
}
- 运行效果
go run cmd/kingpin/main.go
usage: completion [<flags>] <command> [<args>
My application with bash completion.
Flags:
--help Show context-sensitive help (also try --help-long and --help-man).
--flag-1=FLAG-1
--flag-2=FLAG-2
Commands:
help [<command>
Show help.
nc --host=HOST --port=PORT [<flags>]
Connect to a Host
ls [<flags>]
Additional top level command to show command completion
ping [<flags>]
Additional top level command to show command completion
nmap [<flags>]
Additional top level command to show command completion
说明
以上是几个整理的cli，后期会继续完善
参考资料
https://github.com/google/subcommands
https://github.com/urfave/cli
https://github.com/mitchellh/cli
https://github.com/alecthomas/kingpin
http://github.com/spf13/cobra
https://github.com/rongfengliang/cliapp
