前言

最近应为一直在写Go,避免不了要处理一些命令行参数和配置文件。虽然Go原生的flag库比起其他语言,在处理命令行参数上已经做的很易用了,Go的社区也有很多好用的库。这篇文章主要介绍一下自己这段时间接触使用过库,为有同样需求的朋友也提供一些参考。

flag

首先还是有必要简单介绍一下Go的原生库flag, 直接上代码

基本用法

var id = flag.Int("id", 1, "user id")
var mail = flag.String("mail", "test@gmail.com", "mail")
var help = flag.Bool("h", false, "this help")

也可以用指针变量去接收flag

var name string
flag.StringVar(&name, "name", "leeif", "your name")

变量也可以是一个实现flag.Value接口的结构体

type Address struct {
 s string
}
func (a *Address) String() string {
 return a.s
}
func (a *Address) Set(s string) error {
 if s == "" {
 return errors.New("address can't be empty")
 }
 a.s = s
 return nil
}
ad := Address{}
flag.Var(&ad, "address", "address of the server")

解析

flag.Parse()

完整代码
https://play.golang.org/p/mjgZ6SJMeAm

flagSet可以用来处理subcommand

upload := flag.NewFlagSet("upload", flag.ContinueOnError)
localFile := upload.Bool("localFile", false, "")
download := flag.NewFlagSet("download", flag.ContinueOnError)
remoteFile := download.Bool("remoteFile", false, "")
switch os.Args[1] {
 case "upload":
 if err := upload.Parse(os.Args[2:]); err == nil {
 fmt.Println("upload", *localFile)
 }
 case "download":
 if err := download.Parse(os.Args[2:]); err == nil {
 fmt.Println("download", *remoteFile)
 }
}

命令行的指定形式。

-flag (也可以是--flag)
-flag=x
-flag x // non-boolean flags only

原生的flag在简单的需求下,已经够用了,但是想构建一些复杂的应用的时候还是有些不方便。然而flag的可扩展性也衍生了许多各具特色的第三方库。

kingpin

https://github.com/alecthomas...

一些主要的特点:

• fluent-style的编程风格
• 不仅可以解析flag, 也可以解析非flag参数
• 支持短参数的形式
• sub command

一般的使用方法

debug = kingpin.Flag("debug", "Enable debug mode.").Bool()
// 可被环境变量覆盖的flag
// Short方法可以指定短参数
timeout = kingpin.Flag("timeout", "Timeout waiting for ping.").Default("5s").OverrideDefaultFromEnvar("PING_TIMEOUT").Short('t').Duration()
// IP类型的参数
// Required参数为必须指定的参数
ip = kingpin.Arg("ip", "IP address to ping.").Required().IP()
count = kingpin.Arg("count", "Number of packets to send").Int()

用指针类型接收flag

var test string
kingpin.Flag("test", "test flag").StringVar(&test)

实现kingpin.Value接口的参数类型

type Address struct {
 s string
}
func (a *Address) String() string {
 return a.s
}
func (a *Address) Set(s string) error {
 if s == "" {
 return errors.New("address can't be empty")
 }
 a.s = s
 return nil
}
ad := Address{}
kingpin.Flag("address", "address of the server").SetValue

解析

kingpin.Parse()

使用sub command

var (
 deleteCommand = kingpin.Command("delete", "Delete an object.")
 deleteUserCommand = deleteCommand.Command("user", "Delete a user.")
 deleteUserUIDFlag = deleteUserCommand.Flag("uid", "Delete user by UID rather than username.")
 deleteUserUsername = deleteUserCommand.Arg("username", "Username to delete.")
 deletePostCommand = deleteCommand.Command("post", "Delete a post.")
)
func main() {
 switch kingpin.Parse() {
 case deleteUserCommand.FullCommand():
 case deletePostCommand.FullCommand():
 }
}

kingpin会自动生成help文案。不用做任何设置用--help即可查看。-h则需要手动配置。

kingpin.HelpFlag.Short('h')

cobra

https://github.com/spf13/cobra
cobra是go程序员必须要知道的一款命令行参数库。很多大的项目都是用cobra搭建的。
cobra是为应用级的命令行工具而生的项目, 不仅提供了基本的命令行处理功能外, 而提供了一套搭建命令行工具的架构。

cobra的核型架构。

▾ appName/
 ▾ cmd/
 root.go
 sub.go
 main.go

所有的命令行配置分散写在各个文件中, 例如 root.go

package cmd
import (
 "fmt"
 "os"
 "github.com/spf13/cobra"
)
func init() {
 rootCmd.PersistentFlags().StringVarP(&projectBase, "projectbase", "b", "", "base project directory eg. github.com/spf13/")
}
var rootCmd = &cobra.Command{
 Use: "hugo",
 Short: "Hugo is a very fast static site generator",
 Long: `A Fast and Flexible Static Site Generator built with
 love by spf13 and friends in Go.
 Complete documentation is available at http://hugo.spf13.com`,
 Run: func(cmd *cobra.Command, args []string) {
 // Do Stuff Here
 },
}
func Execute() {
 if err := rootCmd.Execute(); err != nil {
 fmt.Println(err)
 os.Exit(1)
 }
}

sub.go

package cmd
import (
 "fmt"
 "github.com/spf13/cobra"
)
func init() {
 rootCmd.AddCommand(subCmd)
}
var subCmd = &cobra.Command{
 Use: "sub command",
 Short: "short description",
 Long: `long description`,
 Run: func(cmd *cobra.Command, args []string) {
 fmt.Println("sub command")
 },
}

在最外面的main.go里,只用写一句话。

package main
import (
 "{pathToYourApp}/cmd"
)
func main() {
 cmd.Execute()
}

用cobra的架构来搭建命令行工具会使架构更清晰。

viper

https://github.com/spf13/viper
viper使用来专门处理配置文件的工具, 因为作者和cobra的作者是同一个人, 所以经常和cobra一起配合着使用。就连cobra的官方说明里也
提到了viper。

viper.SetConfigName("config") // name of config file (without extension)
viper.AddConfigPath("/etc/appname/") // path to look for the config file in
viper.AddConfigPath("$HOME/.appname") // call multiple times to add many search paths
viper.AddConfigPath(".") // optionally look for config in the working directory
err := viper.ReadInConfig() // Find and read the config file
if err != nil { // Handle errors reading the config file
 panic(fmt.Errorf("Fatal error config file: %s \n", err))
}

获取读取到的参数, 为map[string]interface{}类型。

c := viper.AllSettings()

viper也提供处理flag的功能,但是个人感觉没有上面两个库好用,这里也就不做介绍了。

kiper

往往我们要同时处理命令行参数和配置文件, 并且我们想合并这两种参数。

虽然可以用cobra+viper可以实现, 但是个人喜欢kingpin, 因为kingpin可以检查参数的正确性(通过实现kingpin.Value接口的数据类型)。

于是自己写了一个kingpin+viper的wrapper工具, kiper。
https://github.com/leeif/kiper

主要特点:

• 通过tag配置flag设定(kingpin)
• 通过viper读取配置文件
• 自动合并flag和配置文件参数

具体用法

package main
import (
 "errors"
 "fmt"
 "os"
 "strconv"
 "github.com/leeif/kiper"
)
type Server struct {
 Address *Address `kiper_value:"name:address"`
 Port *Port `kiper_value:"name:port"`
}
type Address struct {
 s string
}
func (address *Address) Set(s string) error {
 if s == "" {
 return errors.New("address can't be empty")
 }
 address.s = s
 return nil
}
func (address *Address) String() string {
 return address.s
}
type Port struct {
 p string
}
func (port *Port) Set(p string) error {
 if _, err := strconv.Atoi(p); err != nil {
 return errors.New("not a valid port value")
 }
 port.p = p
 return nil
}
func (port *Port) String() string {
 return port.p
}
type Config struct {
 ID *int `kiper_value:"name:id;required;default:1"`
 Server Server `kiper_config:"name:server"`
}
func main() {
 // initialize config struct
 c := &Config{
 Server: Server{
 Address: &Address{},
 Port: &Port{},
 },
 }
 // new kiper
 k := kiper.NewKiper("example", "example of kiper")
 k.SetConfigFileFlag("config", "config file", "./config.json")
 k.Kingpin.HelpFlag.Short('h')
 // parse command line and config file
 if err := k.Parse(c, os.Args[1:]); err != nil {
 fmt.Println(err)
 os.Exit(1)
 }
 fmt.Println(c.Server.Port)
 fmt.Println(*c.ID)
}

配置文件需要和Config结构体保持一致。

config.json

{
 "server": {
 "address": "192.0.0.1",
 "port": "8080"
 },
 "id": 2
}

有待改善的地方

• 现在还没有做sub command的功能。
• 合并的时候配置文件总会覆盖命令行参数(合并的优先顺序)

总结

Go社区给开发着提供了多种处理命令行参数和配置文件的工具。每种工具都有各自的特点和应用场景。 例如flag是原生支持,扩展性高。kingpin可以检查参数的正确性。cobra适合构建复杂的命令行工具。开发者可以根据自己搭需求选择使用的工具, 这样的可选性和自由度也正是Go社区最大的魅力。

本文来自:Segmentfault

感谢作者:leeif

查看原文:[Golang] 聊一聊Go的那些处理命令行参数和配置文件的库

• 编辑
• 预览