前言
用过golang的小伙伴应该都知道flag包，因此这边就不做使用的介绍了。本文主要简单分析flag包的源码，以及简单介绍下如何自定义自己的value类型。
本文测试代码如下：
var kk *bool = flag.Bool("k",false,"just k")
func main() {
//flag.Usage()
flag.Parse()
fmt.Println(*kk)
}
代码分析
当我们 import package时，package内的全局变量会进行初始化，并且init函数会执行。对应flag包，代码如下：
var CommandLine = NewFlagSet(os.Args[0], ExitOnError)
func init() {
CommandLine.Usage = commandLineUsage
}
CommandLine 代表的是当前可执行程序的命令行集合，也就是 FlagSet。
CommandLine.Usage从字面理解就是使用说明。
NewFlagSet函数用于构造一个FlagSet，这样的函数命名也是golang推荐的。
对于FlagSet结构体，我们可以先看下它的定义：
type FlagSet struct {
Usage func()
name string //FlagSet名字，被赋值为 os.Args[0]
parsed bool //是否被解析过
actual map[string]*Flag //在实际命令行中使用到的Flag
formal map[string]*Flag //在代码中预定义的全部Flag
args []string //等于 os.Args[1:]
errorHandling ErrorHandling
output io.Writer
}
注意从 Flag包中导出的函数最终都会调用到 CommandLine 对应的函数，所以这里我只分析 FlagSet 的对应函数。
Flag包初始化的过程之后，接下来就到测试代码的分析：
var kk *bool = flag.Bool("k",false,"just k")
三个参数分别为 name,default value,usage。
func (f *FlagSet) Bool(name string, value bool, usage string) *bool {
p := new(bool)
f.BoolVar(p, name, value, usage)
return p
}
函数简单明了，new出一个p，通过 FlagSet.BoolVar的处理，p会承接命令行中的值，然后直接返回p的指针。
所以最关键的函数在于 FlagSet.BoolVar 函数。
func (f *FlagSet) BoolVar(p *bool, name string, value bool, usage string) {
f.Var(newBoolValue(value, p), name, usage)
}
BoolVar 先调用 newBoolValue，之后调用 f.Var。
func newBoolValue(val bool, p *bool) *boolValue{
*p = val
return (*boolValue)(p)
}
newBoolValue功能只有一个，把默认值赋给 p，并将p转换成 boolValue指针类型，然后返回。
注意 boolValue 拥有成员函数： Set/String/Get，因此boolValue实现了 flag.Value，fmt.Stringer，flag.Getter接口。
func (f *FlagSet) Var(value Value, name string, usage string) {
flag := &Flag{name, usage, value, value.String()}
_, alreadythere := f.formal[name]
if alreadythere {
var msg string
if f.name == "" {
msg = fmt.Sprintf("flag redefined: %s", name)
} else {
msg = fmt.Sprintf("%s flag redefined: %s", f.name, name)
}
fmt.Fprintln(f.Output(), msg)
panic(msg)
}
if f.formal == nil {
f.formal = make(map[string]*Flag)
}
f.formal[name] = flag
}
FlagSet.Var函数首先新建一个 Flag结构体，然后检查对应的 flag的name是否存在于 FlagSet的formal slice中，如果存在同名flag，直接panic。
如果不存在则直接把flag存放在 formal中。
至此，预定义的flag已经存放在 CommandLine 中。
之后我们分析 flag.Parse函数。
func (f *FlagSet) Parse(arguments []string) error {
f.parsed = true
f.args = arguments
for {
seen, err := f.parseOne()
......
}
}
其中 arguments 等于 os.Args[1:]，因此Flag.Args()得到的是纯正的命令行参数，不包括 os.Args[0]。但是要千万注意，parseOne 函数会一直更新 FlagSet.args slice，从而导致 Parse结束后，Flag.Args() 得到的是一个空的 slice。
Parse函数中，最主要的函数是 FlagSet.ParseOne 函数。
ParseOne 的函数同样很简单，解析 “-” 符号，根据 “=” 的位置，解析出 name 与 value，其中很关键的代码：
fv, ok := flag.Value.(boolFlag)
fv.Set(value)
这里 Set 由Value接口定义，因此如果我们自定义参数类型的话，必须实现 Value 接口。
函数最后 flag会被添加到 FlagSet.actual 中。
基本的代码分析到这，里面还有一些比较简单的函数，比如usage相关，arg相关的函数，可以自己看看。
自定义Flag
根据上面代码的分析，只要我们定义的Flag结构体实现了Value接口，即能通过命令行初始化。下面代码为例：
type myFlag struct {
name string
age int
}
func (mf *myFlag) Set(data string) error {
b := bytes.NewBufferString(data)
fmt.Fscanf(b,"%d%s",&mf.age,&mf.name)
return nil
}
func (mf *myFlag)String() string {
return fmt.Sprintf("%s now is %d",mf.name,mf.age)
}
var mf *myFlag = &myFlag{}
func init() {
flag.CommandLine.Var(mf,"na","name age")
}
func main() {
//flag.Usage()
flag.Parse()
fmt.Println(mf)
}
在实现 Value接口后，主要需要调用 flag.CommandLine.Var ，当然也可以调用 flag.Var 函数。
