关于Golang标准库flag的全面讲解

Golang
330
0
0
2023-02-05
go的并发小知识
上一篇
Go爬虫(http、goquery和colly)详解
下一篇
目录
  • 命令行参数
  • 使用详解
  • 选项语法
  • flag是怎么解析参数的？
  • 自定义数据类型
  • 短选项
  • 小结

前言：

今天来聊聊Go语言标准库中一个非常简单的库flag，这个库的代码量只有1000行左右，却提供了非常完善的命令行参数解析功能。

命令行参数

如果你有使用过类Unix(比如MacOS,Linux)等操作系统，相信你应该明白命令参数是什么，比如下面的两条命令：

$ mysql -u root -p 123456
$ ls -al

第一条命令是MySQL的客户端，其-u root和-p 123456就是命令行参数，第二条命令用于显示当前目录的文件及目录，该命令中-al就是命令行参数。

flag库的作用就是帮我们将命令后面的选项参数解析到对应的变量中。

使用详解

要了解一个库，须从使用开始，下面我们通过一个简单的示例来快速了解flag库的使用，这个示例可以接收从命令行传递的用于连接数据库的参数，

代码如下：

package main
import (
	"flag"
	"fmt"
)

var (
	host     string
	dbName   string
	port     int
	user     string
	password string
)
func main() {

	flag.StringVar(&host, "host", "", "数据库地址")
	flag.StringVar(&dbName, "db_name", "", "数据库名称")
	flag.StringVar(&user, "user", "", "数据库用户")
	flag.StringVar(&password, "password", "", "数据库密码")
	flag.IntVar(&port, "port", 3306, "数据库端口")
	flag.Parse()
	fmt.Printf("数据库地址:%s\n", host)
	fmt.Printf("数据库名称:%s\n", dbName)
	fmt.Printf("数据库用户:%s\n", user)
	fmt.Printf("数据库密码:%s\n", password)
	fmt.Printf("数据库端口:%d\n", port)
}

在命令行窗口输入以下命令，开始运行程序

go run main.go -host=localhost -user=test -password=123456 -db_name=test -port=3306

运行结束，输出结果如下所示：

数据库地址:localhost
数据库名称:test
数据库用户:test
数据库密码:123456
数据库端口:3306

上面的示例就是一个解析命令行选项参数的模板，包括下面三个步骤：

  • 定义好接收参数的变量。
  • 调用flag.StringVar()等函数将命令行选项与变量绑定。
  • 调用flag.Parse()函数，开始解析变量。

在上面程序中，我们用了StringVar函数绑定字符串类型的参数，用了IntVar函数绑定整数类型的参数，除了字符串和整型，flag支持boolean，Duration，float64，Int64，uint，uint64等类型，下面是这些函数的定义，用法与StringVar相同。

func BoolVar(p *bool, name string, value bool, usage string)
func DurationVar(p *time.Duration, name string, value time.Duration, usage string)
func Float64Var(p *float64, name string, value float64, usage string)
func Int64Var(p *int64, name string, value int64, usage string)
func IntVar(p *int, name string, value int, usage string)
func StringVar(p *string, name string, value string, usage string)
func Uint64Var(p *uint64, name string, value uint64, usage string)
func UintVar(p *uint, name string, value uint, usage string)

上面列出的函数带有Var后缀，表示需要我们自己传递一个变量去接收命令行参数，而flag在这些函数有基础上，封装了下面列表的函数，这些函数没有Var后缀，跟上面的函数相比少了一个参数，却多了一个返回值，这个返回值就是接收命令参数的变量指针。

func Bool(name string, value bool, usage string) *bool
func Duration(name string, value time.Duration, usage string) *time.Duration
func Float64(name string, value float64, usage string) *float64
func Int(name string, value int, usage string) *int
func Int64(name string, value int64, usage string) *int64
func String(name string, value string, usage string) *string
func Uint(name string, value uint, usage string) *uint
func Uint64(name string, value uint64, usage string) *uint64

所以我们把上面的示例改写为以下的样子：

package main
import (
	"flag"
	"fmt"
)
func main() {
	host := flag.String("host", "", "数据库地址")
	dbName := flag.String("db_name", "", "数据库名称")
	user := flag.String("user", "", "数据库用户")
	password := flag.String("password", "", "数据库密码")
	port := flag.Int("port", 3306, "数据库端口")

	flag.Parse()
	fmt.Printf("数据库地址:%s\n", *host)
	fmt.Printf("数据库名称:%s\n", *dbName)
	fmt.Printf("数据库用户:%s\n", *user)
	fmt.Printf("数据库密码:%s\n", *password)
	fmt.Printf("数据库端口:%d\n", *port)
}

另外，运行程序时，在后面跟上-h或--help来查看命令的参数选项，如：

go run main.go --help
Usage of main:
  -db_name string
        数据库名称
  -host string
        数据库地址
  -password string
        数据库密码
  -port int
        数据库端口 (default 3306)
  -user string
        数据库用户

选项语法

flag支持以下三种命令行格式，参数前面的-也可以换成--，在flag库中，--并不是表示长选项的意思。

cmd -flag
cmd -flag=x
cmd -flag x
  • 第一种只用布尔值的选项，如果该参数出现，则为true,不出则为默认值，而其他数据类型不能使用这种格式传值。
  • 第二种可适用任何类型，因此也是最常用的格式。
  • 第三种不可用于布尔值的选项。

flag在解析参数时，如果遇到第一个非选项参数(不是以-或--开头的)或终止符--，就会停止解析，

比如上面的示例中，我们将运行命令改成下面的样子：

go run main.go -host=localhost noflag -user=test -password=123456 -db_name=test -port=3306

运行结果如下，可以看到解析-host参数之后遇到了noflag这样的非选项参数，flag就停止解析了，所以后面的参数都只输出了默认值。

数据库地址:localhost
数据库名称:
数据库用户:
数据库密码:
数据库端口:3306

整数类型的参数可以接收十进制、八进制，十六进制的参数，布尔型可以接收下面列出参数

1, 0, t, f, T, F, true, false, TRUE, FALSE, True, False

Duration类型的参数接收可以被time.ParseDuration()解析的参数。

flag是怎么解析参数的？

我们知道flag库是用于命令行解析的，但其内部是怎么解析的呢？下面我们来分析一下

一个命令行参数包含以下四个部分：

  • 接收参数的变量
  • 参数名称
  • 默认值
  • 参数说明

所以flag设置命令行参数的函数有四个参数，比如：

var p int
flag.IntVar(&p,"port",3306,"数据库端口")

flag内部有一个名称CommandLine的变量，其类型为FlagSet，如：

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

FlagSet就是一个命令行参数的集合体，当我们调用诸如IntVar这类的函数时，就是将命令行的默认值、参数说明，参数名称，接收参数的变量等信息告诉flag库，而flag内部会让CommandLine来处理，用这些信息创建Flag类型的变量，将添加到这个集合体中。

flag := &Flag{name, usage, value, value.String()}

最后，当我们调用flag.Parse函数时，实际就是调用FlagSet结构体的Parse函数将命令参数解析到变量中，flag.Parse函数代码如下：

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

从上面的代码我们也可以看出来，FlagSet的Parse函数最终是通过获取os.Args数组的数据来解析命令行参数的。

即然我们知道flag是通过类型为FlagSet的变量CommandLine来处理命令行参数的，那其实我们也可以自己创建一个FlagSet类型的变量来处理命令行参数，

所以我们可以将上面的例改成下面的样子：

package main
import (
	"flag"
	"fmt"
	"os"
)
func main() {
    //自己创建一个命令行参数的集合
	var flagSet = flag.NewFlagSet("my flag", flag.ExitOnError)

	host := flagSet.String("host", "", "数据库地址")
	dbName := flagSet.String("db_name", "", "数据库名称")
	user := flagSet.String("user", "", "数据库用户")
	password := flagSet.String("password", "", "数据库密码")
	port := flagSet.Int("port", 3306, "数据库端口")

    //解析命令行参数，从os.Args的第二个元素开始，第一个元素是命令本身
	flagSet.Parse(os.Args[1:])

	fmt.Printf("数据库地址:%s\n", *host)
	fmt.Printf("数据库名称:%s\n", *dbName)
	fmt.Printf("数据库用户:%s\n", *user)
	fmt.Printf("数据库密码:%s\n", *password)
	fmt.Printf("数据库端口:%d\n", *port)

}

另外，我们已经知道了flag解析参数的来源是os.Args这样的字符串数组，那我们也可以模拟一个这样的数组，将数组解析到变量之中，而不需要去解析os.Args数组，

下面的例子就是这样做的：

package main
import (
	"flag"
	"fmt"
)
func main() {
    //模拟os.Args数组，定义一个参数数组
	var params = []string{"-host", "127.0.0.1", "-db_name", "test", "-user", "test", "-password", "abcdef", "-port", "13306"}

	var flagSet = flag.NewFlagSet("my flag", flag.ExitOnError)

	host := flagSet.String("host", "", "数据库地址")
	dbName := flagSet.String("db_name", "", "数据库名称")
	user := flagSet.String("user", "", "数据库用户")
	password := flagSet.String("password", "", "数据库密码")
	port := flagSet.Int("port", 3306, "数据库端口")

    //解析自定义的参数数组
	flagSet.Parse(params)
	fmt.Printf("数据库地址:%s\n", *host)
	fmt.Printf("数据库名称:%s\n", *dbName)
	fmt.Printf("数据库用户:%s\n", *user)
	fmt.Printf("数据库密码:%s\n", *password)
	fmt.Printf("数据库端口:%d\n", *port)

}

运行程序，在命令后面不需要跟命令行参数，如下：

go run main.go

运行后结果如下：

数据库地址:127.0.0.1
数据库名称:test
数据库用户:test
数据库密码:abcdef
数据库端口:13306

自定义数据类型

如果flag提供的数据类型不能满足我们的需要，我们也可以自定义类型，自定义类型需要实现flag中的Value接口，该接口定义如下：

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

Value类型的String()用于打印数值，而Set方法则用于flag包将命令行参数设置到Value类型中。

下面是一个自定义类型的示例程序：

package main

import (
	"flag"
	"fmt"
	"strings"
)
type Users []string
func (u *Users) Set(val string) error {
	*u = strings.Split(val, ",")
	return nil
}
func (u *Users) String() string {
	str := "["
	for _, v := range *u {
		str += v
	}
	return str + "]"
}

func main() {
	var u Users
	flag.Var(&u, "u", "用户列表")
	flag.Parse()

	for _, v := range u {
		fmt.Println(v)
	}
}

运行结果：

 go run main.go -u=小明,小张,小红,小刚
小明
小张
小红
小刚

从上面的示例中我们可以总结自定义类型的几个步骤：

  • 定义一个实现flag.Value接口的类型，并实现String和Set方法。
  • 使用flag.Var函数将类型绑定到类型参数。
  • 调用flag.Parse()解析命令行参数。

短选项

我们在使用Linux命令的时候，发现很多命令的参数是有分短选项和长选项的，不过flag库并不支持短选项；当然也有变通的方式，比如我们可以自己定义一个长选项和短选项，

如：

var port int
flag.IntVar(&port, "p", 3306, "数据库端口")
flag.IntVar(&port, "port", 3306, "数据库端口")
flag.Parse()

fmt.Println(port)

上面的程序中，我们定义了p和port两个参数，并将其绑定到变量port，因此通过下面两条命令都可以获取参数：

$ go run main.go -p 111
$ go run main.go -port 111

小结

在这篇文章中，我们全面讲解了flag库，看完这篇文章，相信你可以学习到以下几点：

  • 在Go程序员中如何使用flag库解析命令行参数。
  • flag库解析命令行参数的原理。
  • 怎么让flag库支持我们自定义的数据类型。
  • 怎么定义命令行参数短选项。
go的并发小知识
上一篇
Go爬虫(http、goquery和colly)详解
下一篇