Go命令行参数解析flag 包使用示例详解

var ip = flag.Int("flagname", 1234, "help message for flagname")

var flagvar intflag.IntVar(&flagvar, "flagname", 1234, "help message for flagname")

flag.Var(&flagVal, "name", "help message for flagname")

flag.Parse()

fmt.Println("flagvar has value ", flagvar)

package main
import (
  "flag"
  "fmt"
)
func main() {
  username := flag.String("name", "", "Input your username")
  flag.Parse()
  fmt.Println("Hello, ", *username)
}

go build flag.go

./flag -name=world

type FlagSet struct {
        Usage func()
}

package main
import (
    "flag"
    "fmt"
)
var myFlagSet = flag.NewFlagSet("myflagset", flag.ExitOnError)
var stringFlag = myFlagSet.String("abc", "default value", "help mesage")
func main() {
    myFlagSet.Parse([]string{"-abc", "def", "ghi", "123"})
    args := myFlagSet.Args()
    for i := range args {
        fmt.Println(i, myFlagSet.Arg(i))
    }
}

package main
import (
	"fmt"
	"os"
)
func main() {
	commandArgs := os.Args
	fmt.Println(commandArgs)
}

# 执行程序: 递归浏览指定目录下所有文件
go run main.go --name ls --value /etc -r
# 输出: [/tmp/go-build2637413899/b001/exe/main --name ls --value /etc -r]

使用flag的流程:
1. 初始化存放命令行参数的全局变量
2. 在main包的init函数中注册需要解析的命令行参数，包含参数的类型、参数存放到哪个变量、参数的名称、参数的默认值、参数的使用说明
3. 在定义解析命令行参数最后，添加 flag.Parse()，解析传递到程序的命令行参数到变量中
4. 主函数中通过全局变量引用命令行参
5. 运行主函数，通过 -<参数名>=<value> 或  -<参数名> <value> 方式传参
解析命令行参数的基本文法:
1. flag.<类型>Var(<指针>, <参数名称>, <默认值>, <用法说明>)
2. 等价方法: flag.<类型>(<参数名称>, <默认值>, <用法说明>)
- 区别在于，Var后缀方法是通过指针将值存放到指针指向的变量，未带Var后缀的方法返回一个指定值的指针
- 相同的，参数值不同则使用不同的类型，都包含参数的名称、参数的默认值、该参数使用说明
- 类型是基本数据类型：int int64 uint uint64 string bool fl0at64 Duration

package main
import (
	"flag"
	"fmt"
)
// 1. 声明保存命令行参数的变量
var (
	name        string
	value       string
	isRecursive bool
)
func init() {
	// 2. 注册需要解析的命令行参: 参数名、默认值、参数说明
	flag.StringVar(&name, "name", "none", "执行命令的名称")
	flag.StringVar(&value, "value", "none", "执行命令的参数")
	flag.BoolVar(&isRecursive, "recursive", false, "是否递归")
	// 3. 解析命令行参数
	flag.Parse()
}
func main() {
	// 4. 主程序中通过全局变量引用命令行参
	fmt.Println(name, value, isRecursive)
}

# 输出：ls /etc true
go run main.go -name ls -value /etc -recursive

# 输出: ls /etc false
go run main.go -name ls -value /etc

package main
import (
	"flag"
	"fmt"
)
// 1. 声明保存命令行参数的变量
var (
	name string
)
func init() {
	// 2. 声明需要解析的命令行参: 参数名、默认值、参数说明
	flag.StringVar(&name, "name", "none", "执行命令的名称")
	// 将name的值修改为 find
	flag.Set("name", "find")
}
func main() {
	// 4. 主程序中通过全局变量引用命令行参
	fmt.Println(name)
}

# 输出：find
go run main.go -name ls

package main
import (
	"flag"
	"fmt"
)
// 1. 声明保存命令行参数的变量
var (
	name        string
	value       string
	isRecursive bool
)
func init() {
	flag.StringVar(&name, "name", "none", "执行命令的名称")
	flag.StringVar(&value, "value", "none", "执行命令的参数")
	flag.BoolVar(&isRecursive, "recursive", false, "是否递归")
	flag.Parse()
}
func main() {
	fmt.Println("number of set flag:", flag.NFlag())
}

package main
import (
	"flag"
	"fmt"
)
// 1. 声明保存命令行参数的变量
var (
	name        string
	value       string
	isRecursive bool
)
func init() {
	flag.StringVar(&name, "name", "none", "执行命令的名称")
	flag.StringVar(&value, "value", "none", "执行命令的参数")
	flag.BoolVar(&isRecursive, "recursive", false, "是否递归")
	flag.Parse()
}
func main() {
	fmt.Println("is Parsed", flag.Parsed())
}

package main
import (
	"flag"
	"fmt"
)
// 1. 声明保存命令行参数的变量
var (
	name        string
	value       string
	isRecursive bool
)
func init() {
	flag.StringVar(&name, "name", "none", "执行命令的名称")
	flag.StringVar(&value, "value", "none", "执行命令的参数")
	flag.BoolVar(&isRecursive, "recursive", false, "是否递归")
	flag.Parse()
}
func main() {
	flag.Visit(func(f *flag.Flag) {
		fmt.Printf("Name: %s, Value: %s, DefValue: %s, Usage: %s \n", f.Name, f.Value, f.DefValue, f.Usage)
	})
}