golang flag包源碼閱讀

前言

用過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 函數。