[[416691]]

我上周五喝酒喝到晚上3點多，確實有點罩不住啊，整個周末都在休息和睡覺，文章鴿了幾天，想不到就有兩個人跑了。

不得不感嘆一下，自媒體的太殘酷了，時效就那么幾天，斷更就沒人愛。你們說好了愛我的，愛呢?哼

昨晚就在寫這篇文章了，沒想到晚上又遇到發(fā)版本，確實不容易，且看且珍惜。

• 標準庫 flag
• flag的簡寫方式
• 從源碼來看flag如何解析參數(shù)
• 從源碼想到的拓展用法
• 小結(jié)
• 引用

標準庫 flag

命令行程序應(yīng)該能打印出幫助信息，傳遞其他命令行參數(shù)，比如-h就是flag庫的默認幫助參數(shù)。

./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程序，上面所示的四個參數(shù)，是我自定義的。

按提示的方法，可以像這樣使用參數(shù)。

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

像上面-version這樣的參數(shù)是bool類型的，只要指定了就會設(shè)置為true，不指定時為默認值，假如默認值是true，想指定為false要像下面這樣顯式的指定(因為源碼里是這樣寫的)。

./goapi -version=false 

下面這幾種格式都是兼容的

-isbool    #同于 -isbool=true 
-age=x     #-和等號 
-age x     #-和空格 
--age=x    #2個-和等號 
--age x    #2個-和空格 

flag庫綁定參數(shù)的過程很簡單，格式為

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和端口等功能。

綁定完參數(shù)還沒完，還得調(diào)用解析函數(shù)flag.Parse()，注意一定要在使用參數(shù)前調(diào)用哦，使用過程像下面這樣：

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函數(shù)里，不太雅觀，建議把這些單獨放到一個包里，或者放在main函數(shù)的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如何解析參數(shù)

其實我們把之前的綁定方式打開來看，在源碼里就是調(diào)用了xxVar函數(shù)，以Bool類型為例。

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

上面的代碼用到了BoolVal函數(shù)，它的功能是把需要綁定的變量設(shè)置為默認值，并調(diào)用f.Var進一步處理，這里p是一個指針，所以只要改變指向的內(nèi)容，就可以影響到外部綁定所用的變量：

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 函數(shù)可以得到一個boolValue類型，它是bool類型重命名的。在此包中所有可作為參數(shù)的類型都有這樣的定義。
• 在flag包的設(shè)計中有兩個重要的類型，F(xiàn)lag和FlagSet分別表示某個特定的參數(shù)，和一個無重復的參數(shù)集合。

f.Var函數(shù)的作用就是把參數(shù)封裝成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結(jié)構(gòu)體中起作用的是formal map[string]*Flag類型，所以說，flag把程序中需要綁定的變量包裝成一個字典，后面解析的時候再一一賦值。

我們已經(jīng)知道了，在調(diào)用Parse的時候，會對參數(shù)解析并為變量賦值，使用時就可以得到真實值。展開看看它的代碼

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

Parse的代碼里用到了一個，CommandLine共享變量，這就是內(nèi)部庫維護的FlagSet，所有的參數(shù)都會插到里面的變量地址向地址的指向賦值綁定。

上面提到FlagSet綁定的Parse函數(shù)，看看它的內(nèi)容：

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 
} 

• 上面的函數(shù)內(nèi)容太長了，我收縮了一下。
• 可看到解析的過程實際上是多次調(diào)用了parseOne()，它的作用是逐個遍歷命令行參數(shù)，綁定到Flag，就像翻頁一樣。
• 用switch對應(yīng)處理錯誤，決定退出碼或直接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 
 // ...如果不存在，或者需要輸出幫助信息，則返回 
 // ...設(shè)置真實值調(diào)用到 flag.Value.Set(value) 
 if f.actual == nil { 
  f.actual = make(map[string]*Flag) 
 } 
 f.actual[name] = flag 
 return true, nil 
} 

• parseOne 內(nèi)部會解析一個輸入?yún)?shù)，判斷輸入?yún)?shù)格式，獲取參數(shù)值。
• 解析過程就是逐個取出程序參數(shù)，判斷-、=取參數(shù)與參數(shù)值
• 解析后查找之前提到的formal map中有沒有存在此參數(shù)，并設(shè)置真實值。
• 把設(shè)置完畢真實值的參數(shù)放到f.actual map中，以供它用。
• 一些錯誤處理和細節(jié)的代碼我省略掉了，感興趣可以自行看源碼。
• 實際上就是逐個參數(shù)解析并設(shè)置到對應(yīng)的指針變量的指向上，讓返回值出現(xiàn)變化。

flag.Value.Set(value) 這里是設(shè)置數(shù)據(jù)真實值的代碼，Value長這樣

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

它被設(shè)計成一個接口，不同的數(shù)據(jù)類型自己實現(xiàn)這個接口，返回給用戶的地址就是這個接口的實例數(shù)據(jù)，解析過程中，可以通過 Set 方法修改它的值，這個設(shè)計確實還挺巧妙的。

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這個結(jié)構(gòu)體，它是最核心的解析類。

在庫內(nèi)部提供了一個 *FlagSet 的實例對象 CommandLine，它通過NewFlagSet方法創(chuàng)建。并且對它的所有方法封裝了一下直接對外。

官方的意思很明確了，說明我們可以用到它做些更高級的事情。先看看官方怎么用的。

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

可以看到調(diào)用的時候是傳入命令行第一個參數(shù)，第二個參數(shù)表示報錯時應(yīng)該呈現(xiàn)怎樣的錯誤。

那就意味著我們可以根據(jù)命令行第一個參數(shù)不同而呈現(xiàn)不同的表現(xiàn)!

我定義了兩個參數(shù)foo或者bar，代表兩個不同的指令集合，每個指令集匹配不同的命令參數(shù)，效果如下：

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

這是怎么實現(xiàn)的呢?其實就是用NewFlagSet方法創(chuàng)建多個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參數(shù)。
• 綁定錯誤時退出。
• 分別為每個FlagSet綁定要解析的變量。
• 如果判斷命令行輸入?yún)?shù)少于2個時退出(因為第0個參數(shù)是程序名本身)。

然后根據(jù)第一個參數(shù)，判斷應(yīng)該匹配到哪個指令集：

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來切換命令行參數(shù)，綁定不同的變量。
• 對應(yīng)不同變量輸出不同表現(xiàn)。
• x.Args()可以打印未匹配到的其他參數(shù)。

補充：使用NewFlagSet時，flag 提供三種錯誤處理的方式:

• ContinueOnError: 通過 Parse 的返回值返回錯誤
• ExitOnError: 調(diào)用 os.Exit(2) 直接退出程序，這是默認的處理方式
• PanicOnError: 調(diào)用 panic 拋出錯誤

小結(jié)

通過本節(jié)我們了解到了標準庫flag的使用方法，參數(shù)變量綁定的兩種方式，還通過源碼解析了內(nèi)部實現(xiàn)是如何的巧妙。

我們還使用源碼暴露出來的函數(shù)，接收不同參數(shù)匹配不同指令集，這種方式可以讓應(yīng)用呈現(xiàn)完成不同的功能;

我想到的是用來通過環(huán)境變量改變命令用法、或者讓程序復用大段邏輯呈現(xiàn)不同作用時使用。

但現(xiàn)在微服務(wù)那么流行，大多功能集成在一個服務(wù)里是不科學的，如果有重復代碼應(yīng)該提煉成共同模塊才是王道。

你還想到能哪些使用場景呢?

引用

源碼包 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

往期精彩回顧

本文轉(zhuǎn)載自微信公眾號「機智的程序員小熊」，可以通過以下二維碼關(guān)注。轉(zhuǎn)載本文請聯(lián)系機智的程序員小熊公眾號。