前言
日常开发使用到的命令行工具大都支持如下特性:
- 文档自动生成(如 -h --help)
- 多级子命令(如 docker exec -it)
- 支持参数(如 ls -color=auto)
- 长短选项(如 -v 和 --verbose)
- 全局选项(如 docker -d run -d nginx)
- tab 自动补全
本文就探讨一下 go 语言中如何写一个拥有类似特性的命令行程序。
os.args
类似于 shell 中的 $1
$2
,在 go 中可以使用 os.args
来获取命令行参数,这种临时使用一两个参数还可以,代码可维护性太差了,不推荐使用。
其中 args[0] 是程序的名称,args[1] 是第一个参数,依此类推。
flag 快速开始
go 标准库自带的 flag
包可以实现简单的命令行解析,我们模仿一下 ls
命令的参数,示例如下:
func main() { // 直接定义 flag,返回值为指针 all := flag.bool("all", true, "do not ignore entries starting with .") color := flag.string("color", "omitted", "colorize the output") // 也可以将 flag 绑定到变量 var almostall bool flag.boolvar(&almostall, "almost-all", false, "do not list implied . and ..") // 除过上面的 bool string 还有 int float64 等其他常用类型 flag.parse() // parse 后就可以获取到具体参数的值 fmt.println(*all, *color, almostall) }
可以看到非常简单的几行代码,就实现了一个还不错的命令行小工具,支持 -
和 --
(效果是一致的),对于非 bool 类型的 flag 其值支持 -flag=val
或者 -flag val
。
长短选项
短选项书写快捷,适合在终端下面执行,而长选项可读性高,适合在脚本中书写,通过共享一个变量,即可达到此效果
func main() { var name string defaultval := "tom" useage := "your name" flag.stringvar(&name, "n", defaultval, useage+" (shorthand)") flag.stringvar(&name, "name", defaultval, useage) flag.parse() fmt.println(name) }
自定义类型
flag
也支持我们自定义参数的类型,方便我们对参数的格式,输出形式做更加自由的处理,更好的封装。
type durations []time.duration func (d *durations) string() string { return fmt.sprint(*d) } func (d *durations) set(value string) error { // 支持逗号分割的参数,如:-d 1m,2s,1h // 也支持 -d 1m -d 2s -d 1h 这种写法 // 如果不想 -d 被指定多次,可以加上这段 if 逻辑 // if len(*d) > 0 { // return errors.new("-d flag already set") // } for _, v := range strings.split(value, ",") { duration, err := time.parseduration(v) if err != nil { return err } *d = append(*d, duration) } return nil } func main() { var param durations // 第一个参数是接口类型,我们自定义的 durations 只需要实现 string() 和 set() 方法即可 flag.var(¶m, "d", "time duration, comma-separated list") flag.parse() fmt.println(param) }
二级子命令
在说二级子命令前,我们先看一下 flag
的核心流程,帮助我们更好的理解二级子命令的实现。
// src/flag/flag.go // 代表了每一个 flag,如 --name=tom type flag struct { name string // name as it appears on command line usage string // help message value value // value as set defvalue string // default value (as text); for usage message } // 代表本次命令输出的所有 flag ,如 -l --size=10 --verbose type flagset struct { usage func() name string parsed bool actual map[string]*flag formal map[string]*flag args []string // arguments after flags errorhandling errorhandling output io.writer // nil means stderr; use output() accessor }
在快速开始的代码中,核心代码就两句,就对应了 flag
的流程,先注册后解析。
color := flag.string("color", "omitted", "colorize the output") flag.parse()
追着 flag.string
可以看到它其实调用的是 commandline.string
,commandline
是一个全局的 flagset
实例,最终 flag.string
会调用 flagset
的 var
方法,完成所有命令的注册。
// src/flag/flag.go func string(name string, value string, usage string) *string { return commandline.string(name, value, usage) } var commandline = newflagset(os.args[0], exitonerror) // 省略到校验的一部分逻辑,可以看到核心就是 f.formal[name] = flag func (f *flagset) var(value value, name string, usage string) { // ... // remember the default value as a string; it won't change. flag := &flag{name, usage, value, value.string()} // ... if f.formal == nil { f.formal = make(map[string]*flag) } f.formal[name] = flag }
flag.parse
则最终调用的是 flagset
的 parse
方法,完成实际输入值的解析。
func (f *flagset) parse(arguments []string) error { f.parsed = true f.args = arguments for { // 循环直到所有的 flag 都解析完成 seen, err := f.parseone() if seen { continue } // ... } return nil }
在理解了上面了流程后,我们就基于 flagset
来模仿一下 docker
的二级命令,代码如下:
type myflagset struct { *flag.flagset cmdcomment string // 二级子命令本身的注释 } func main() { // docker ps pscmd := &myflagset{ flagset: flag.newflagset("ps", flag.exitonerror), cmdcomment: "list containers", } pscmd.bool("a", false, "show all containers (default shows just running)") pscmd.bool("s", false, "display total file sizes") // docker run runcmd := &myflagset{ flagset: flag.newflagset("run", flag.exitonerror), cmdcomment: "run a command in a new container", } runcmd.int("c", 1, "cpu shares (relative weight)") runcmd.string("name", "", "assign a name to the container") // 用 map 保存所有的二级子命令,方便快速查找 subcommands := map[string]*myflagset{ pscmd.name(): pscmd, runcmd.name(): runcmd, } useage := func() { // 整个命令行的帮助信息 fmt.printf("usage: docker command\n\n") for _, v := range subcommands { fmt.printf("%s %s\n", v.name(), v.cmdcomment) v.printdefaults() // 使用 flag 库自带的格式输出子命令的选项帮助信息 fmt.println() } os.exit(2) } if len(os.args) < 2 { // 即没有输入子命令 useage() } cmd := subcommands[os.args[1]] // 第二个参数必须是我们支持的子命令 if cmd == nil { useage() } cmd.parse(os.args[2:]) // 注意这里是 cmd.parse 不是 flag.parse,且值是 args[2:] // 输出解析后的结果 fmt.println("command name is:", cmd.name()) cmd.visit(func(f *flag.flag) { fmt.printf("option %s, value is %s\n", f.name, f.value) }) }
可以看到效果还不错呢,到目前为止,除了全局选项和自动补全未实现,其他的特性都有了,可以看到总体来说 flag
简单易用,对于一些小程序来说完全足够了。
当然对于比较复杂的程序,还是推荐使用更加强大的 cobra,可以参考笔者写的 markdown 小帮手 marker
参考
https://pkg.go.dev/flag
https://gobyexample.com/command-line-subcommands
到此这篇关于go flag 详解,实现二级子命令的文章就介绍到这了,更多相关go flag二级子命令内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持!