上篇文章 介绍了 flag 中如何扩展一个新的类型支持。本篇介绍如何使用 flag 实现子命令，总的来说，这篇才是这个系列的核心，前两篇只是铺垫。
前两篇文章链接如下：
Go 命令行解析 flag 包之快速上手
Go 命令行解析 flag 包之扩展新类型
希望看完本篇文章，如果再阅读 go 命令的实现源码，至少在整体结构上不会迷失方向了。
FlagSet#
正式介绍子命令的实现之前，先了解下 flag 包中的一个类型，FlagSet，它表示了一个命令。
从命令的组成要素上看，一个命令由命令名、选项 Flag 与参数三部分组成。类似如下：
$ cmd --flag1 --flag2 -f=flag3 arg1 arg2 arg3FlagSet 的定义也正符合了这一点，如下：
type FlagSet struct {
// 打印命令的帮助信息
Usage func()
// 命令名称
name string
parsed bool
// 实际传入的 Flag
actual map[string]*Flag
// 会被使用的 Flag，通过 Flag.Var() 加入到了 formal 中
formal map[string]*Flag
// 参数，Parse 解析命令行传入的 []string，
// 第一个不满足 Flag 规则的（如不是 - 或 -- 开头），
// 从这个位置开始，后面都是
args []string // arguments after flags
// 发生错误时的处理方式，有三个选项，分别是
// ContinueOnError 继续
// ExitOnError 退出
// PanicOnError panic
errorHandling ErrorHandling
output io.Writer // nil means stderr; use out() accessor
}包含字段有命令名 name，选项 Flag 有 formal 和 actual，参数 args。
如果有人说，FlagSet 是命令行实现的核心，还是比较认同的。之所以前面一直没有提到它，主要是 flag 包为了简化命令行的处理流程，在 FlagSet 上做了进一步的封装，简单的使用可以直接无视它的存在。
flag 中定义了一个全局的 FlagSet 类型变量，CommandLine，用它表示整个命令行。可以说，CommandLine 是 FlagSet 的一个特例，它的使用模式较为固定，所以在它之上能提供了一套默认的函数。
前面已经用过的一些，比如下面这些函数。
func BoolVar(p *bool, name string, value bool, usage string) {
CommandLine.Var(newBoolValue(value, p), name, usage)
}
func Bool(name string, value bool, usage string) *bool {
return CommandLine.Bool(name, value, usage)
}
func Parse() {
// Ignore errors; CommandLine is set for ExitOnError.
CommandLine.Parse(os.Args[1:])
}更多的，这里不一一列举了。
接下来，我们来脱掉这层外衣，梳理下命令行的整个处理流程吧。
流程解读#
CommandLine 的整个使用流程主要由三部分组成，分别是获取命令名称、定义命令中的实际选项和解析选项。
命令名称在 CommandLine 创建的时候就已经指定了，如下：
CommandLine = NewFlagSet(os.Args[0], ExitOnError)名称由 os.Args[0] 指定，即命令行的第一个参数。除了命令名称，同时指定的还有出错时的处理方式，ExitOnError。
接着是定义命令中实际会用到的 Flag。
核心的代码是 FlagSet.Var()，如下所示：
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.BoolVar 和 flag.Bool 都是通过 CommandLine.Var()，即 FlagSet.Var()， 将 Flag 保存到 FlagSet.formal 中，以便于之后在解析的时候能将值成功设置到定义的变量中。
最后一步是从命令行中解析出选项 Flag。由于 CommandLine 表示的是整个命令行，所以它的选项和参数一定是从 os.Args[1:] 中解析。
flag.Parse 的代码如下：
func Parse() {
// Ignore errors; CommandLine is set for ExitOnError.
CommandLine.Parse(os.Args[1:])
}现在的重点是要了解 flag 中选项和参数的解析规则，如 gvg -v list，按什么规则确定 -v 是一个 Flag，而 list 是参数的呢？
如果继续向下追 Parse 的源码，在 FlagSet.parseOne 中将发现 Flag 的解析规则。
func (f *FlagSet) ParseOne()
if len(f.args) == 0 {
return false, nil
}
s := f.args[0]
if len(s) < 2 || s[0] != '-' {
return false, nil
}
numMinuses := 1
if s[1] == '-' {
numMinuses++
if len(s) == 2 { // "--" terminates the flags
f.args = f.args[1:]
return false, nil
}
}
// ...
}三种情况下会终止解析 Flag，分别是当命令行参数全部解析结束，即 len(f.args) == 0，或长度小于 2，但第一位字符不是 -，或者参数长度等于 2，且第二个字符是 -。之后的内容会继续当作命令行参数处理。
如果没有子命令，命令的解析工作到此就基本完成了，再往后就是业务代码的开发了。那如果 CommandLine 还有子命令呢？
子命令#
子命令和 CommandLine 无论是形式还是逻辑上，基本没什么差异。形式上，子命令同样包含选项和参数，逻辑上，子命令的选项和参数的解析规则与 CommandLine 相同。
一个包含子命令的命令行，形式如下：
$ cmd --flag1 --flag2 subcmd --subflag1 --subflag2 arg1 arg2从上面可以看出，如果 CommandLine 包含了子命令，可以理解为本身也就没了参数，因为 CommandLine 的第一个参数即是子命令的名称，而之后的参数要解析为子命令的选项参数了。
现在，子命令的实现就变得非常简单了，创建一个新的 FlagSet，将 CommandLine 中的参数按前面介绍的流程重新处理一下。
第一步，获取 CommandLine.Arg(0)，检查是否存在相应的子命令。
func main() {
flag.Parse()
if h {
flag.Usage()
return
}
cmdName := flag.Arg(0)
switch cmdName {
case "list":
_ = list.Exec(cmdName, flag.Args()[1:])
case "install":
_ = install.Exec(cmdName, flag.Args()[1:])
}
}子命令的实现定义在另外一个包中，以 list 命令为例。 代码如下：
var flagSet *flag.FlagSet
var origin string
func init() {
flagSet = flag.NewFlagSet("list", flag.ExitOnError)
val := newStringEnumValue("installed", &origin, []string{"installed", "local", "remote"})
flagSet.Var(
val, "origin",
"the origin of version information, such as installed, local, remote",
)
}上面的代码中，定义了 list 子命令的 FlagSet，并在 Init 方法为其增加了一个选项 Flag，origin。
Run 函数是真正执行业务逻辑的代码。
func Run(args []string) error {
if err := flagSet.Parse(args); err != nil {
return err
}
fmt.Println("list --oriign", origin)
return nil
}最后的 Exec 函数组合 Init 和 Run 函数，已提供给 main 调用。
func Run(name string, args []string) error {
Init(name)
if err := Run(args); err != nil {
return err
}
return nil
}命令行的解析完成，如果子命令还有子命令，处理的逻辑依然相同。接下来的工作，就可以开始在 Run 函数中编写业务代码了。
Go 命令#
现在，阅读下 Go 命令的实现代码吧。
由于大佬们写的代码是基于 flag 包实现纯手工打造，没用任何的框架，在可读性上会有点差。
源码位于 go/src/cmd/go/cmd/main.go 下，通过 base.Go 变量初始化了 Go 支持的所有命令，如下：
base.Go.Commands = []*base.Command{
bug.CmdBug,
work.CmdBuild,
clean.CmdClean,
doc.CmdDoc,
envcmd.CmdEnv,
fix.CmdFix,
fmtcmd.CmdFmt,
generate.CmdGenerate,
modget.CmdGet,
work.CmdInstall,
list.CmdList,
modcmd.CmdMod,
run.CmdRun,
test.CmdTest,
tool.CmdTool,
version.CmdVersion,
vet.CmdVet,
help.HelpBuildmode,
help.HelpC,
help.HelpCache,
help.HelpEnvironment,
help.HelpFileType,
modload.HelpGoMod,
help.HelpGopath,
get.HelpGopathGet,
modfetch.HelpGoproxy,
help.HelpImportPath,
modload.HelpModules,
modget.HelpModuleGet,
modfetch.HelpModuleAuth,
modfetch.HelpModulePrivate,
help.HelpPackages,
test.HelpTestflag,
test.HelpTestfunc,
}无论是 go 命令，还是它的子命令，都是 *base.Command 类型。可以看一下 *base.Command 的定义。
type Command struct {
Run func(cmd *Command, args []string)
UsageLine string
Short string
Long string
Flag flag.FlagSet
CustomFlags bool
Commands []*Command
}主要的字段有三个，分别是 Run，主要负责业务逻辑的处理，FlagSet，负责命令行的解析，以及 []*Command， 所支持的子命令。
再来看看 main 函数中的核心逻辑。如下：
BigCmdLoop:
for bigCmd := base.Go; ; {
for _, cmd := range bigCmd.Commands {
// ...
// 主要逻辑代码
// ...
}
// 打印帮助信息
helpArg := ""
if i := strings.LastIndex(cfg.CmdName, " "); i >= 0 {
helpArg = " " + cfg.CmdName[:i]
}
fmt.Fprintf(os.Stderr, "go %s: unknown command\nRun 'go help%s' for usage.\n", cfg.CmdName, helpArg)
base.SetExitStatus(2)
base.Exit()
}从最顶层的 base.Go 开始，遍历 Go 的所有子命令，如果没有相应的命令，则打印帮助信息。
省略的那段主要逻辑代码如下：
for _, cmd := range bigCmd.Commands {
// 如果找不到命令，继续下次循环
if cmd.Name() != args[0] {
continue
}
// 检查是否存在子命令
if len(cmd.Commands) > 0 {
// 将 bigCmd 设置为当前的命令
// 比如 go tool compile，cmd 即为 compile
bigCmd = cmd
args = args[1:]
// 如果没有命令参数，则说明不符合命令规则，打印帮助信息。
if len(args) == 0 {
help.PrintUsage(os.Stderr, bigCmd)
base.SetExitStatus(2)
base.Exit()
}
// 如果命令名称是 help，打印这个命令的帮助信息
if args[0] == "help" {
// Accept 'go mod help' and 'go mod help foo' for 'go help mod' and 'go help mod foo'.
help.Help(os.Stdout, append(strings.Split(cfg.CmdName, " "), args[1:]...))
return
}
// 继续处理子命令
cfg.CmdName += " " + args[0]
continue BigCmdLoop
}
if !cmd.Runnable() {
continue
}
cmd.Flag.Usage = func() { cmd.Usage() }
if cmd.CustomFlags {
// 解析参数和选项 Flag
// 自定义处理规则
args = args[1:]
} else {
// 通过 FlagSet 提供的方法处理
base.SetFromGOFLAGS(cmd.Flag)
cmd.Flag.Parse(args[1:])
args = cmd.Flag.Args()
}
// 执行业务逻辑
cmd.Run(cmd, args)
base.Exit()
return
}主要是几个部分，分别是查找命令，检查是否存在子命令，选项和参数的解析，以及最后是命令的执行。
通过 cmd.Name() != args[0] 判断是否查找到了命令，如果找到则继续向下执行。
通过 len(cmd.Commands) 检查是否存在子命令，存在将 bigCmd 覆盖，并检查是否符合命令行是否符合规范，比如检查 len(args[1:]) 如果为 0，则说明传入的命令行没有提供子命令。如果一切就绪，通过 continue 进行下一次循环，执行子命令的处理。
接着是命令选项和参数的解析。可以自定义处理规则，也可以直接使用 FlagSet.Parse 处理。
最后，调用 cmd.Run 执行逻辑处理。
总结#
本文介绍了 Go 中如何通过 flag 实现子命令，从 FlagSet 这个结构体讲起，通过 flag 包中默认提供的 CommandLine 梳理了 FlagSet 的处理逻辑。在基础上，实现了子命令的相关功能。
本文最后，分析了 Go 源码中 go 如何使用 flag 实现。因为是纯粹使用 flag 包裸写，读起来稍微有点难度。本文只算是一个引子，至少帮助大家在大的方向不至于迷路，里面更多的细节还需要自己挖掘。