从源码的角度看Go语言Flag库如何解析命令行参数！

我上周五喝酒喝到晚上3点多，确实有点罩不住啊，整个周末都在休息和睡觉，文章鸽了几天，想不到就有两个人跑了。

不得不感叹一下，自媒体的太残酷了，时效就那么几天，断更就没人爱。你们说好了爱我的，爱呢?哼

昨晚就在写这篇文章了，没想到晚上又遇到发版本，确实不容易，且看且珍惜。

• 标准库 flag
• flag的简写方式
• 从源码来看flag如何解析参数
• 从源码想到的拓展用法
• 小结
• 引用

标准库 flag

命令行程序应该能打印出帮助信息，传递其他命令行参数，比如-h就是flag库的默认帮助参数。

 
 
 
 

  
  
  
  
./goapi -h
  
  
  
  
Usage of ./goapi:
  
  
  
  
  -debug
  
  
  
  
        is debug
  
  
  
  
  -ip string
  
  
  
  
        Input bind address (default "127.0.0.1")
  
  
  
  
  -port int
  
  
  
  
        Input bind port (default 80)
  
  
  
  
  -version
  
  
  
  
        show version information
 
 
 
 

goapi是我build出来的一个二进制go程序，上面所示的四个参数，是我自定义的。

按提示的方法，可以像这样使用参数。

 
 
 
 

  
  
  
  
./goapi -debug -ip 192.168.1.1
  
  
  
  
./goapi -port 8080
  
  
  
  
./goapi -version
 
 
 
 

像上面-version这样的参数是bool类型的，只要指定了就会设置为true，不指定时为默认值，假如默认值是true，想指定为false要像下面这样显式的指定(因为源码里是这样写的)。

 
 
 
 

  
  
  
  
./goapi -version=false
 
 
 
 

下面这几种格式都是兼容的

 
 
 
 

  
  
  
  
-isbool    #同于 -isbool=true
  
  
  
  
-age=x     #-和等号
  
  
  
  
-age x     #-和空格
  
  
  
  
--age=x    #2个-和等号
  
  
  
  
--age x    #2个-和空格
 
 
 
 

flag库绑定参数的过程很简单，格式为

 
 
 
 

  
  
  
  
flag.(name string, value bool, usage string) *类型
 
 
 
 

如下是详细的绑定方式：

 
 
 
 

  
  
  
  
var (
  
  
  
  
    showVersion = flag.Bool("version", false, "show version information")
  
  
  
  
    isDebug = flag.Bool("debug", false, "is debug")
  
  
  
  
    ip      = flag.String("ip", "127.0.0.1", "Input bind address")
  
  
  
  
    port    = flag.Int("port", 80, "Input bind port")
  
  
  
  
)
 
 
 
 

可以定义任意类型的变量，比如可以表示是否debug模式、让它来输出版本信息、传入需要绑定的ip和端口等功能。

绑定完参数还没完，还得调用解析函数flag.Parse()，注意一定要在使用参数前调用哦，使用过程像下面这样：

 
 
 
 

  
  
  
  
func main() {
  
  
  
  
 flag.Parse()
  
  
  
  
 if *showVersion {
  
  
  
  
  fmt.Println(version)
  
  
  
  
  os.Exit(0)
  
  
  
  
 }
  
  
  
  
 if *isDebug {
  
  
  
  
  fmt.Println("set log level: debug")
  
  
  
  
 }
  
  
  
  
 fmt.Println(fmt.Sprintf("bind address: %s:%d successfully",*ip,*port))
  
  
  
  
}
 
 
 
 

全部放在main函数里，不太雅观，建议把这些单独放到一个包里，或者放在main函数的init()里，看起来不仅舒服，也便于阅读。

flag的简写方式

有时候可能我们要给某个全局配置变量赋值，flag提供了一种简写的方式，不用额外定义中间变量。像下面这样

 
 
 
 

  
  
  
  
var (
  
  
  
  
 ip          string
  
  
  
  
 port        int
  
  
  
  
)
  
  
  
  

  
  
  
  
func init() {
  
  
  
  
 flag.StringVar(&ip, "ip", "127.0.0.1", "Input bind address(default: 127.0.0.1)")
  
  
  
  
 flag.IntVar(&port, "port", 80, "Input bind port(default: 80)")
  
  
  
  
}
  
  
  
  
func main() {
  
  
  
  
 flag.Parse()
  
  
  
  
 fmt.Println(fmt.Sprintf("bind address: %s:%d successfully", ip, port))
  
  
  
  
}
 
 
 
 

这样写可以省掉很多判断的代码，也避免了使用指针，命令行的使用方法还是一样的。

从源码来看flag如何解析参数

其实我们把之前的绑定方式打开来看，在源码里就是调用了xxVar函数，以Bool类型为例。

 
 
 
 

  
  
  
  
func (f *FlagSet) Bool(name string, value bool, usage string) *bool {
  
  
  
  
 p := new(bool)
  
  
  
  
 f.BoolVar(p, name, value, usage)
  
  
  
  
 return p
  
  
  
  
}
 
 
 
 

上面的代码用到了BoolVal函数，它的功能是把需要绑定的变量设置为默认值，并调用f.Var进一步处理，这里p是一个指针，所以只要改变指向的内容，就可以影响到外部绑定所用的变量：

 
 
 
 

  
  
  
  
func (f *FlagSet) BoolVar(p *bool, name string, value bool, usage string) {
  
  
  
  
 f.Var(newBoolValue(value, p), name, usage)
  
  
  
  
}
  
  
  
  

  
  
  
  
type boolValue bool
  
  
  
  

  
  
  
  
func newBoolValue(val bool, p *bool) *boolValue {
  
  
  
  
 *p = val
  
  
  
  
 return (*boolValue)(p)
  
  
  
  
}
 
 
 
 

• newBoolValue 函数可以得到一个boolValue类型，它是bool类型重命名的。在此包中所有可作为参数的类型都有这样的定义。
• 在flag包的设计中有两个重要的类型，Flag和FlagSet分别表示某个特定的参数，和一个无重复的参数集合。

f.Var函数的作用就是把参数封装成Flag，并合并到FlagSet中，下面的代码就是核心过程：

 
 
 
 

  
  
  
  
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()}
  
  
  
  
 _, alreadythere := f.formal[name]
  
  
  
  
 if alreadythere {
  
  
  
  
  //...错误处理省略
  
  
  
  
 }
  
  
  
  
 if f.formal == nil {
  
  
  
  
  f.formal = make(map[string]*Flag)
  
  
  
  
 }
  
  
  
  
 f.formal[name] = flag
  
  
  
  
}
 
 
 
 

FlagSet结构体中起作用的是formal map[string]*Flag类型，所以说，flag把程序中需要绑定的变量包装成一个字典，后面解析的时候再一一赋值。

我们已经知道了，在调用Parse的时候，会对参数解析并为变量赋值，使用时就可以得到真实值。展开看看它的代码

 
 
 
 

  
  
  
  
func Parse() {
  
  
  
  
 // Ignore errors; CommandLine is set for ExitOnError.
  
  
  
  
 // 调用了FlagSet.Parse
  
  
  
  
 CommandLine.Parse(os.Args[1:])
  
  
  
  
}
  
  
  
  
// 返回一个FlagSet
  
  
  
  
var CommandLine = NewFlagSet(os.Args[0], ExitOnError)
 
 
 
 

Parse的代码里用到了一个，CommandLine共享变量，这就是内部库维护的FlagSet，所有的参数都会插到里面的变量地址向地址的指向赋值绑定。

上面提到FlagSet绑定的Parse函数，看看它的内容：

 
 
 
 

  
  
  
  
func (f *FlagSet) Parse(arguments []string) error {
  
  
  
  
 f.parsed = true
  
  
  
  
 f.args = arguments
  
  
  
  
 for {
  
  
  
  
  seen, err := f.parseOne()
  
  
  
  
  if seen { continue }
  
  
  
  
  if err == nil {...}
  
  
  
  
  switch f.errorHandling {
  
  
  
  
  case ContinueOnError: return err
  
  
  
  
  case ExitOnError:
  
  
  
  
   if err == ErrHelp { os.Exit(0) }
  
  
  
  
   os.Exit(2)
  
  
  
  
  case PanicOnError: panic(err)
  
  
  
  
  }
  
  
  
  
 }
  
  
  
  
 return nil
  
  
  
  
}
 
 
 
 

• 上面的函数内容太长了，我收缩了一下。
• 可看到解析的过程实际上是多次调用了parseOne()，它的作用是逐个遍历命令行参数，绑定到Flag，就像翻页一样。
• 用switch对应处理错误，决定退出码或直接panic。

parseOne就是解析命令行输入绑定变量的过程了：

 
 
 
 

  
  
  
  
func (f *FlagSet) parseOne() (bool, error) {
  
  
  
  
 //...
  
  
  
  
 s := f.args[0]
  
  
  
  
 //...
  
  
  
  
 if s[1] == '-' { ...}
  
  
  
  
 name := s[numMinuses:]
  
  
  
  
 if len(name) == 0 || name[0] == '-' || name[0] == '=' {
  
  
  
  
  return false, f.failf("bad flag syntax: %s", s)
  
  
  
  
 }
  
  
  
  

  
  
  
  
 f.args = f.args[1:]
  
  
  
  
 //...
  
  
  
  
 m := f.formal
  
  
  
  
 flag, alreadythere := m[name] // BUG
  
  
  
  
 // ...如果不存在，或者需要输出帮助信息，则返回
  
  
  
  
 // ...设置真实值调用到 flag.Value.Set(value)
  
  
  
  
 if f.actual == nil {
  
  
  
  
  f.actual = make(map[string]*Flag)
  
  
  
  
 }
  
  
  
  
 f.actual[name] = flag
  
  
  
  
 return true, nil
  
  
  
  
}
 
 
 
 

• parseOne 内部会解析一个输入参数，判断输入参数格式，获取参数值。
• 解析过程就是逐个取出程序参数，判断-、=取参数与参数值
• 解析后查找之前提到的formal map中有没有存在此参数，并设置真实值。
• 把设置完毕真实值的参数放到f.actual map中，以供它用。
• 一些错误处理和细节的代码我省略掉了，感兴趣可以自行看源码。
• 实际上就是逐个参数解析并设置到对应的指针变量的指向上，让返回值出现变化。

flag.Value.Set(value) 这里是设置数据真实值的代码，Value长这样

 
 
 
 

  
  
  
  
type Value interface {
  
  
  
  
    String() string
  
  
  
  
    Set(string) error
  
  
  
  
}
 
 
 
 

它被设计成一个接口，不同的数据类型自己实现这个接口，返回给用户的地址就是这个接口的实例数据，解析过程中，可以通过 Set 方法修改它的值，这个设计确实还挺巧妙的。

 
 
 
 

  
  
  
  
func (b *boolValue) String() string {
  
  
  
  
  return strconv.FormatBool(bool(*b)) 
  
  
  
  
}
  
  
  
  
func (b *boolValue) Set(s string) error {
  
  
  
  
    v, err := strconv.ParseBool(s)
  
  
  
  
    if err != nil {
  
  
  
  
        err = errParse  
  
  
  
  
    }
  
  
  
  
    *b = boolValue(v)
  
  
  
  
    return err
  
  
  
  
}
 
 
 
 

从源码想到的拓展用法

flag的常用方法也学会了，基本原理也了解了，我怎么那么厉害。哈哈哈。

有没有注意到整个过程都围绕了FlagSet这个结构体，它是最核心的解析类。

在库内部提供了一个 *FlagSet 的实例对象 CommandLine，它通过NewFlagSet方法创建。并且对它的所有方法封装了一下直接对外。

官方的意思很明确了，说明我们可以用到它做些更高级的事情。先看看官方怎么用的。

 
 
 
 

  
  
  
  
var CommandLine = NewFlagSet(os.Args[0], ExitOnError)
 
 
 
 

可以看到调用的时候是传入命令行第一个参数，第二个参数表示报错时应该呈现怎样的错误。

那就意味着我们可以根据命令行第一个参数不同而呈现不同的表现!

我定义了两个参数foo或者bar，代表两个不同的指令集合，每个指令集匹配不同的命令参数，效果如下：

 
 
 
 

  
  
  
  
$ ./subcommands 
  
  
  
  
expected 'foo' or 'bar' subcommands
  
  
  
  

  
  
  
  
$ ./subcommands foo -h
  
  
  
  
Usage of foo:
  
  
  
  
  -enable
  
  
  
  
        enable
  
  
  
  
        
  
  
  
  
$./subcommands foo -enable
  
  
  
  
subcommand 'foo'
  
  
  
  
  enable: true
  
  
  
  
  tail: []
 
 
 
 

这是怎么实现的呢?其实就是用NewFlagSet方法创建多个FlagSet再分别绑定变量，如下：

 
 
 
 

  
  
  
  
fooCmd := flag.NewFlagSet("foo", flag.ExitOnError)
  
  
  
  
fooEnable := fooCmd.Bool("enable", false, "enable")
  
  
  
  

  
  
  
  
barCmd := flag.NewFlagSet("bar", flag.ExitOnError)
  
  
  
  
barLevel := barCmd.Int("level", 0, "level")
  
  
  
  

  
  
  
  
if len(os.Args) < 2 {
  
  
  
  
    fmt.Println("expected 'foo' or 'bar' subcommands")
  
  
  
  
    os.Exit(1)
  
  
  
  
}
 
 
 
 

• 定义两个不同的FlagSet，接受foo或bar参数。
• 绑定错误时退出。
• 分别为每个FlagSet绑定要解析的变量。
• 如果判断命令行输入参数少于2个时退出(因为第0个参数是程序名本身)。

然后根据第一个参数，判断应该匹配到哪个指令集：

 
 
 
 

  
  
  
  
switch os.Args[1] {
  
  
  
  
case "foo":
  
  
  
  
    fooCmd.Parse(os.Args[2:])
  
  
  
  
    fmt.Println("subcommand 'foo'")
  
  
  
  
    fmt.Println("  enable:", *fooEnable)
  
  
  
  
    fmt.Println("  tail:", fooCmd.Args())
  
  
  
  
case "bar":
  
  
  
  
    barCmd.Parse(os.Args[2:])
  
  
  
  
    fmt.Println("subcommand 'bar'")
  
  
  
  
    fmt.Println("  level:", *barLevel)
  
  
  
  
    fmt.Println("  tail:", barCmd.Args())
  
  
  
  
default:
  
  
  
  
    fmt.Println("expected 'foo' or 'bar' subcommands")
  
  
  
  
    os.Exit(1)
  
  
  
  
}
 
 
 
 

• 使用switch来切换命令行参数，绑定不同的变量。
• 对应不同变量输出不同表现。
• x.Args()可以打印未匹配到的其他参数。

补充：使用NewFlagSet时，flag 提供三种错误处理的方式:

• ContinueOnError: 通过 Parse 的返回值返回错误
• ExitOnError: 调用 os.Exit(2) 直接退出程序，这是默认的处理方式
• PanicOnError: 调用 panic 抛出错误

小结

通过本节我们了解到了标准库flag的使用方法，参数变量绑定的两种方式，还通过源码解析了内部实现是如何的巧妙。

我们还使用源码暴露出来的函数，接收不同参数匹配不同指令集，这种方式可以让应用呈现完成不同的功能;

我想到的是用来通过环境变量改变命令用法、或者让程序复用大段逻辑呈现不同作用时使用。

但现在微服务那么流行，大多功能集成在一个服务里是不科学的，如果有重复代码应该提炼成共同模块才是王道。

你还想到能哪些使用场景呢?

引用

源码包 https://golang.org/src/flag/flag.go

命令行子命令 https://gobyexample-cn.github.io/command-line-subcommands

命令行解析库 flag https://segmentfault.com/a/1190000021143456

腾讯云文档flag https://cloud.tencent.com/developer/section/1141707#stage-100022105

往期精彩回顾

本文转载自微信公众号「机智的程序员小熊」，可以通过以下二维码关注。转载本文请联系机智的程序员小熊公众号。

文章题目：从源码的角度看Go语言Flag库如何解析命令行参数！
文章出自：http://www.csdahua.cn/qtweb/news49/376949.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网