前言
日常开发使用到的命令行工具大都支持如下特性：
- 文档自动生成（如 -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二级子命令内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！
