«

Golang中的flag标准库如何使用

时间：2024-5-11 10:53     作者：韩俊     分类： Go语言

这篇文章主要介绍“Golang中的flag标准库如何使用”，在日常操作中，相信很多人在Golang中的flag标准库如何使用问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Golang中的flag标准库如何使用”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

1.使用

1.1示例

flag 基本使用示例代码如下：

package main
import (
    "flag"
    "fmt"
)
type flagVal struct {
    val string
}
func (v *flagVal) String() string {
    return v.val
}
func (v *flagVal) Set(s string) error {
    v.val = s
    return nil
}
func main() {
    // 1. 使用 flag.Type() 返回  *int 类型命令行参数
    var nFlag = flag.Int("n", 1234, "help message for flag n")
    // 2. 使用 flag.TypeVar() 绑定命令行参数到 int 类型变量
    var flagvar int
    flag.IntVar(&flagvar, "flagvar", 1234, "help message for flagvar")
    // 3. 使用 flag.Var() 绑定命令行参数到实现了 flag.Value 接口的自定义类型变量
    val := flagVal{}
    flag.Var(&val, "val", "help message for val")
    // 解析命令行参数
    flag.Parse()
    fmt.Printf("nFlag: %d
", *nFlag)
    fmt.Printf("flagvar: %d
", flagvar)
    fmt.Printf("val: %+v
", val)
    fmt.Printf("NFlag: %v
", flag.NFlag()) // 返回已设置的命令行标志个数
    fmt.Printf("NArg: %v
", flag.NArg())   // 返回处理完标志后剩余的参数个数
    fmt.Printf("Args: %v
", flag.Args())   // 返回处理完标志后剩余的参数列表
    fmt.Printf("Arg(1): %v
", flag.Arg(1)) // 返回处理完标志后剩余的参数列表中第 i 项
}

可以通过指定 

--help/-h
 参数来查看这个命令行程序的使用帮助：

$ go run main.go -h                      
Usage of ./main:
  -flagvar int
        help message for flagvar (default 1234)
  -n int
        help message for flag n (default 1234)
  -val value
        help message for val

这个程序接收三个命令行参数：

    int
     类型的 
    -flagvar
    ，默认值为 
    2134
    。

    int
     类型的 
    -n
    ，默认值为 
    2134
    。

    value
     类型的 
    -val
    ，无默认值。

我们可以将 

-flagvar
、
-n
、
-val
 称作 
flag
，即「标志」，这也是 Go 内置命令行参数解析库被命名为 flag 的原因，见名知意。

这三个参数在示例代码中，分别使用了三种不同形式来指定：

flag.Type()
:

-n
 标志是使用 
var nFlag = flag.Int("n", 1234, "help message for flag n")
 来指定的。

flag.Int
 函数签名如下：

func Int(name string, value int, usage string) *int

flag.Int
 函数接收三个参数，分别是标志名称、标志默认参数值、标志使用帮助信息。函数最终还会返回一个 
*int
 类型的值，表示用户在执行命令行程序时为这个标志指定的参数。

除了使用 

flag.Int
 来设置 
int
 类型标志，flag 还支持其他多种类型，如使用 
flag.String
 来设置 
string
 类型标志。

flag.TypeVar()
:

-flagvar
 标志是使用 
flag.IntVar(&flagvar, "flagvar", 1234, "help message for flagvar")
 来指定的。

flag.IntVar
 函数签名如下：

func IntVar(p *int, name string, value int, usage string)

与 

flag.Int
 不同的是，
flag.IntVar
 函数取消了返回值，而是会将用户传递的命令行参数绑定到第一个参数 
p *int
。

除了使用 

flag.IntVar
 来绑定 
int
 类型参数到标志，flag 还提供其他多个函数来支持绑定不同类型参数到标志，如使用 
flag.StringVar
 来绑定 
string
 类型标志。

flag.Var()
:

-val
 标志是使用 
flag.Var(&val, "val", "help message for val")
 来指定的。

flag.Var
 函数签名如下：

func Var(value Value, name string, usage string)

flag.Var
 函数接收三个参数，后两个参数分别是标志名称、标志使用帮助信息。而用户传递的命令行参数将被绑定到第一个参数 
value
。

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

我们可以自定义类型，只要实现了 

flag.Value
 接口，都可以传递给 
flag.Var
，这极大的增加了 flag 包的灵活性。

定义完三个标志，我们还需要使用 

flag.Parse()
 来解析命令行参数，只有解析成功以后，才会将户传递的命令行参数值绑定到对应的标志变量中。之后就可以使用 
nFlag
、
flagvar
、
val
 的变量值了。

在 

main
 函数底部，使用 
flag.NFlag()
、
flag.NArg()
、
flag.Args()
、
flag.Arg(1)
 几个函数获取并展示了命令行参数相关信息。

现在我们尝试给这个命令行程序传递几个参数并执行它，看下输出结果：

$ go run main.go -n 100 -val test a b c d
nFlag: 100
flagvar: 1234
val: {val:test}
NFlag: 2
NArg: 4
Args: [a b c d]
Arg(1): b

我们通过 

-n 100
 为 
-n
 标志指定了参数值 
100
，最终会被赋值给 
nFlag
 变量。

由于没有指定 

flagvar
 标志的参数值，所以 
flagvar
 变量会被赋予默认值 
1234
。

接着，我们又通过 

-val test
 为 
-val
 标志指定了参数值 
test
，最终赋值给了自定义的 
flagVal
 结构体的 
val
 字段。

因为只设置了 

-n
 和 
-val
 两个标志的参数值，所以函数 
flag.NFlag()
 返回结果为 2。

a b c d
 四个参数由于没有被定义，所以 
flag.NArg()
 返回结果为 4。

flag.Args()
 返回的切片中存储了 
a b c d
 四个参数。

flag.Arg(1)
 返回切片中下标为 
1
 位置的参数，即 
b
。

1.2标志类型

在上面的示例中，我们展示了 

int
 类型和自定义的 
flag.Value
 的使用，flag 包支持的所有标志类型汇总如下：

参数类型合法值
boolstrconv.ParseBool 能够解析的有效值，接受：1, 0, t, f, T, F, true, false, TRUE, FALSE, True, False。
time.Durationtime.ParseDuration 能够解析的有效值，如：”300ms”, “-1.5h” or “2h55m”，合法单位：”ns”, “us” (or “µs”), “ms”, “s”, “m”, “h”。
float64合法的浮点数类型。
int/int64/uint/uint64合法的整数类型，如：1234, 0664, 0x1234，也可以是负数。
string合法的字符串类型。
flag.Value实现了该接口的类型。

除了支持几种 Go 默认的原生类型外，如果我们想实现其他类型标志的定义，都可以通过 

flag.Value
 接口类型来完成。其实 flag 包内部对于 
bool
、
int
 等所有类型的定义，都实现了 
flag.Value
 接口，在稍后讲解源码过程中将会有所体现。

1.3标志语法

命令行标志支持多种语法：

语法说明
-flagbool 类型标志可以使用，表示参数值为 true。
–flag支持两个 
-
 字符，与 -flag 等价。
-flag=x所有类型通用，为标志 flag 传递参数值 x。
-flag x作用等价于 -flag=x，但是仅限非 bool 类型标志使用，假如这样使用 
cmd -x *
，其中 * 是 Unix shell 通配符，如果存在名为 0、false 等文件，则参数值结果会发生变化。

flag 解析参数时会在第一个非标志参数之前（单独的一个 

-
 字符也是非标志参数）或终止符 
--
 之后停止。

2.源码解读

注意：本文以 Go 1.19.4 源码为例，其他版本可能存在差异。

熟悉了 flag 包的基本使用，接下来我们就要深入到 flag 的源码，来探究其内部是如何实现。

阅读 flag 包的源码，我们可以从使用 flag 包的流程来入手。

2.1定义标志

在 

main
 函数中，我们首先通过如下代码定义了一个标志 
-n
。

var nFlag = flag.Int("n", 1234, "help message for flag n")

flag.Int
 函数定义如下：

func Int(name string, value int, usage string) *int {
    return CommandLine.Int(name, value, usage)
}

可以发现，

flag.Int
 函数调用并返回了 
CommandLine
 对象的 
Int
 方法，并将参数原样传递进去。

来看看 

CommandLine
 是个什么：

var CommandLine = NewFlagSet(os.Args[0], ExitOnError)
func NewFlagSet(name string, errorHandling ErrorHandling) *FlagSet {
    f := &FlagSet{
        name:          name,
        errorHandling: errorHandling,
    }
    f.Usage = f.defaultUsage
    return f
}

CommandLine
 是使用 
NewFlagSet
 创建的 
FlagSet
 结构体指针，在构造 
FlagSet
 对象时，需要两个参数 
os.Args[0]
 和 
ExitOnError
。

我们知道 

os.Args
 存储了程序执行时指定的所有命令行参数，
os.Args[0]
 就是当前命令行程序的名称，
ExitOnError
 是一个常量，用来标记在出现 
error
 时应该如何做，
ExitOnError
 表示在遇到 
error
 时退出程序。

来看下 

FlagSet
 是如何定义：

type FlagSet struct {
    Usage func()
    name          string
    parsed        bool
    actual        map[string]*Flag
    formal        map[string]*Flag
    args          []string // arguments after flags
    errorHandling ErrorHandling
    output        io.Writer // nil means stderr; use Output() accessor
}

Usage
 字段是一个函数，根据名字大概能够猜测出，这个函数会在指定 
--help/-h
 参数查看命令行程序使用帮助时被调用。

parsed
 用来标记是否调用过 
flag.Parse()
。

actual
 和 
formal
 分别用来存储从命令行解析的标志参数和在程序中指定的默认标志参数。它们都使用 
map
 来存储 
Flag
 类型的指针，
FlagSet
 可以看作是 
Flag
 结构体的「集合」。

args
 用来保存处理完标志后剩余的参数列表。

errorHandling
 标记在出现 
error
 时应该如何做。

output
 用来设置输出位置，这可以改变 
--help/-h
 时展示帮助信息的输出位置。

现在来看下 

Flag
 的定义：

type Flag struct {
    Name     string // 标志名称
    Usage    string // 帮助信息
    Value    Value  // 标志所对应的命令行参数值
    DefValue string // 用来记录字符串类型的默认值，它不会被改变
}

Flag
 用来记录一个命令行参数，里面存储了一个标志所有信息。

可以说 

Flag
 和 
FlagSet
 两个结构体就是 flag 包的核心，所有功能都是围绕这两个结构体设计的。

标志所对应的命令行参数值为 

flag.Value
 接口类型，在前文中已经见过了，定义如下：

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

之所以使用接口，是为了能够存储任何类型的值，除了 flag 包默认支持的内置类型，用户也可以定义自己的类型，只要实现了 

Value
 接口即可。

如我们在前文示例程序中定义的 

flagVal
 类型。

现在 

CommandLine
 的定义以及内部实现我们都看过了，是时候回过头来看一看 
CommandLine
 对象的 
Int
 方法了：

func (f *FlagSet) Int(name string, value int, usage string) *int {
    p := new(int)
    f.IntVar(p, name, value, usage)
    return p
}

Int
 方法内部调用了 
f.IntVar()
 方法，定义如下：

func (f *FlagSet) IntVar(p *int, name string, value int, usage string) {
    f.Var(newIntValue(value, p), name, usage)
}

IntVar
 方法又调用了 
f.Var()
 方法。

Var
 方法第一个参数为 
newIntValue(value, p)
，我们来看看 
newIntValue
 函数是如何定义的：

type intValue int
func newIntValue(val int, p *int) *intValue {
    *p = val
    return (*intValue)(p)
}
func (i *intValue) Set(s string) error {
    v, err := strconv.ParseInt(s, 0, strconv.IntSize)
    if err != nil {
        err = numError(err)
    }
    *i = intValue(v)
    return err
}
func (i *intValue) Get() any { return int(*i) }
func (i *intValue) String() string { return strconv.Itoa(int(*i)) }

newIntValue
 是一个构造函数，用来创建一个 
intValue
 类型的指针，
intValue
 底层类型实际上是 
int
。

定义 

intValue
 类型的目的就是为了实现 
flag.Value
 接口。

再来看下 

Var
 方法如何定义：

func (f *FlagSet) Var(value Value, name string, usage string) {
    // Flag must not begin "-" or contain "=".
    if strings.HasPrefix(name, "-") {
        panic(f.sprintf("flag %q begins with -", name))
    } else if strings.Contains(name, "=") {
        panic(f.sprintf("flag %q contains =", name))
    }
    // Remember the default value as a string; it won't change.
    flag := &Flag{name, usage, value, value.String()}
    _, alreadythere := f.formal[name]
    if alreadythere {
        var msg string
        if f.name == "" {
            msg = f.sprintf("flag redefined: %s", name)
        } else {
            msg = f.sprintf("%s flag redefined: %s", f.name, name)
        }
        panic(msg) // Happens only if flags are declared with identical names
    }
    if f.formal == nil {
        f.formal = make(map[string]*Flag)
    }
    f.formal[name] = flag
}

name
 参数即为标志名，在 
Var
 方法内部，首先对标志名的合法性进行了校验，不能以 
-
 开头且不包含 
=
。

接着，根据参数创建了一个 

Flag
 类型，并且校验了标志是否被重复定义。

最后将 

Flag
 保存在 
formal
 属性中。

到这里，整个函数调用关系就结束了，我们来梳理一下代码执行流程：

flag.Int
 -> 
CommandLine.Int
 -> 
CommandLine.IntVar
 -> 
CommandLine.Var
。

经过这个调用过程，我们就得到了一个 

Flag
 对象，其名称为 
n
、默认参数值为 
1234
、值的类型为 
intValue
、帮助信息为 
help message for flag n
。并将这个 
Flag
 对象保存在了 
CommandLine
 这个类型为 
FlagSet
 的结构体指针对象的 
formal
 属性中。

我们在示例程序中还使用了另外两种方式定义标志。

使用 

flag.IntVar(&flagvar, "flagvar", 1234, "help message for flagvar")
 定义标志 
-flagvar
。

flag.IntVar
 定义如下：

func IntVar(p *int, name string, value int, usage string) {
    CommandLine.Var(newIntValue(value, p), name, usage)
}

可以发现，

flag.IntVar
 函数内部没有调用 
CommandLine.Int
 和 
CommandLine.IntVar
 的过程，而是直接调用 
CommandLine.Var
。

另外，我们还使用 

flag.Var(&val, "val", "help message for val")
 定义了 
-val
 标志。

flag.Var
 定义如下：

func Var(value Value, name string, usage string) {
    CommandLine.Var(value, name, usage)
}

flag.Var
 函数内部同样直接调用了 
CommandLine.Var
，并且由于参数 
value
 已经是 
Value
 接口类型，可以无需调用 
newIntValue
 这类构造函数将 Go 内置类型转为 
Value
 类型，直接传递参数即可。

2.2解析标志参数

命令行参数定义完成了，终于到了解析部分，可以使用 

flag.Parse()
 解析命令行参数。

flag.Parse
 函数代码如下：

func Parse() {
    CommandLine.Parse(os.Args[1:])
}

内部同样是调用 

CommandLine
 对象对应的方法，并且将除程序名称以外的命令行参数都传递到 
Parse
 方法中，
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 {
            break
        }
        switch f.errorHandling {
        case ContinueOnError:
            return err
        case ExitOnError:
            if err == ErrHelp {
                os.Exit(0)
            }
            os.Exit(2)
        case PanicOnError:
            panic(err)
        }
    }
    return nil
}

首先将 

f.parsed
 标记为 
true
，在调用 
f.Parsed()
 方法时会被返回：

func (f *FlagSet) Parsed() bool {
    return f.parsed
}

接着又将 

arguments
 保存在 
f.args
 属性中。

然后就是循环解析命令行参数的过程，每调用一次 

f.parseOne()
 解析一个标志，直到解析完成或遇到 
error
 退出程序。

parseOne
 方法实现如下：

func (f *FlagSet) parseOne() (bool, error) {
    if len(f.args) == 0 {
        return false, nil
    }
    s := f.args[0]
    if len(s) < 2 || s[0] != '-' {
        return false, nil
    }
    numMinuses := 1
    if s[1] == '-' {
        numMinuses++
        if len(s) == 2 { // "--" terminates the flags
            f.args = f.args[1:]
            return false, nil
        }
    }
    name := s[numMinuses:]
    if len(name) == 0 || name[0] == '-' || name[0] == '=' {
        return false, f.failf("bad flag syntax: %s", s)
    }
    // it's a flag. does it have an argument?
    f.args = f.args[1:]
    hasValue := false
    value := ""
    for i := 1; i < len(name); i++ { // equals cannot be first
        if name[i] == '=' {
            value = name[i+1:]
            hasValue = true
            name = name[0:i]
            break
        }
    }
    m := f.formal
    flag, alreadythere := m[name] // BUG
    if !alreadythere {
        if name == "help" || name == "h" { // special case for nice help message.
            f.usage()
            return false, ErrHelp
        }
        return false, f.failf("flag provided but not defined: -%s", name)
    }
    if fv, ok := flag.Value.(boolFlag); ok && fv.IsBoolFlag() { // special case: doesn't need an arg
        if hasValue {
            if err := fv.Set(value); err != nil {
                return false, f.failf("invalid boolean value %q for -%s: %v", value, name, err)
            }
        } else {
            if err := fv.Set("true"); err != nil {
                return false, f.failf("invalid boolean flag %s: %v", name, err)
            }
        }
    } else {
        // It must have a value, which might be the next argument.
        if !hasValue && len(f.args) > 0 {
            // value is the next arg
            hasValue = true
            value, f.args = f.args[0], f.args[1:]
        }
        if !hasValue {
            return false, f.failf("flag needs an argument: -%s", name)
        }
        if err := flag.Value.Set(value); err != nil {
            return false, f.failf("invalid value %q for flag -%s: %v", value, name, err)
        }
    }
    if f.actual == nil {
        f.actual = make(map[string]*Flag)
    }
    f.actual[name] = flag
    return true, nil
}

parseOne
 代码稍微多一点，不过整体脉络还是比较清晰的。

首先对 

f.args
 参数进行了校验，接着提取标志前导符号 
-
 的个数放到 
numMinuses
 变量中，然后取出标志名并对标志语法做了检查。

接下来取出参数 

value
，并且判断标志名是否为 
-help/-h
，如果是则说明用户只想打印程序使用帮助信息，打印后 
parseOne
 会返回 
ErrHelp
，上层的调用者 
f.Parse
 就会捕获到 
ErrHelp
，然后调用 
os.Exit(0)
 直接退出程序。

其中 

f.usage()
 实现了打印帮助信息的功能，内部具体实现这里就不讲解了，因为基本上是内容排版的实现，不是核心功能，感兴趣可以自己尝试看一看。

最后就是根据参数值是否为 

bool
 类型分别进行参数绑定，将参数设置到对应的标志变量中，并将标志保存到 
f.actual
 中。

以上步骤都执行完成后，在执行 

fmt.Printf("nFlag: %d
", *nFlag)
 时，就能够获取到 
nFlag
 被赋予的参数值了。

至此，flag 包源码的整体脉络都已经清晰了。

2.3其他代码

在我们的示例代码最后，还打印了 

NFlag()
、
NArg()
、
Args()
、
Arg(1)
 几个函数的结果。

这几个函数实现非常简单，代码如下：

func NFlag() int { return len(CommandLine.actual) }
func NArg() int { return len(CommandLine.args) }
func Args() []string { return CommandLine.args }
func Arg(i int) string {
    return CommandLine.Arg(i)
}

由于代码过于简单，我就不进行解释了，相信通过上面的讲解，这几个函数的作用你也能做到一目了然。

flag 包还有一些其他类型，如 

stringValue
、
float64Value
，这些类型实现思路都是一样的，也不再一一讲解。

标签: golang

热门推荐

1 Eclipse怎么安装配置goclipse插件
2 Go语言读取文件的方式有哪些
3 如何在Go中使用Goroutines进行并行计算
4 Go语言中怎么实现tail命令的功能
5 基于go-zero的分布式ID生成系统实现
6 Go的面向对象编程怎么应用
7 如何使用go语言进行分布式任务调度的开发与实现
8 mac golang安装的方法是什么
9 构建高扩展性的分布式任务调度系统：go
10 Go语言如何实现在不同平台上的自动编译和交付

日历

标签

hbase maven eclipse sybase PostgreSQL spring emcache oracle mongodb redis nginx golang java vue android ios mysql linux 微信小程序 css html php教程 javascript python php

搜索

最新文章

热门文章