从源码的角度看Go语言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 -debug -ip 192.168.1.1
./goapi -port 8080
./goapi -version

./goapi -version=false

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

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")
)

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))
}

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))
}

func (f *FlagSet) Bool(name string, value bool, usage string) *bool {
 p := new(bool)
 f.BoolVar(p, name, value, usage)
 return 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)
}

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
}

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

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
}

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
}

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

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
}

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

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

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

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)
}

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)
}