Last active
April 12, 2021 09:27
-
-
Save ggzeng/9e1d4db733c9efc07fdbd155ea85c540 to your computer and use it in GitHub Desktop.
使用flag包做命令行参数解析
官方的example已经比较全面,可以满足一般的使用
根据官方example,使用方法可以总结为下面三步:
1. 定义全局变量来保存命令行参数值
2. 在init()函数中定义参数名与变量的关系
3. 在main()中执行flag.Parse() [Go 命令行解析 flag 包之通过子命令实现看 go 命令源码](https://zhuanlan.zhihu.com/p/94580903)
[Go 命令行解析 flag 包之快速上手](https://mp.w
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// These examples demonstrate more intricate uses of the flag package. | |
package main | |
import ( | |
"errors" | |
"flag" | |
"fmt" | |
"strings" | |
"time" | |
) | |
// Example 1: A single string flag called "species" with default value "gopher". | |
var species = flag.String("species", "gopher", "the species we are studying") | |
// Example 2: Two flags sharing a variable, so we can have a shorthand. | |
// The order of initialization is undefined, so make sure both use the | |
// same default value. They must be set up with an init function. | |
var gopherType string | |
func init() { | |
const ( | |
defaultGopher = "pocket" | |
usage = "the variety of gopher" | |
) | |
flag.StringVar(&gopherType, "gopher_type", defaultGopher, usage) | |
flag.StringVar(&gopherType, "g", defaultGopher, usage+" (shorthand)") | |
} | |
// Example 3: A user-defined flag type, a slice of durations. | |
type interval []time.Duration | |
// String is the method to format the flag's value, part of the flag.Value interface. | |
// The String method's output will be used in diagnostics. | |
func (i *interval) String() string { | |
return fmt.Sprint(*i) | |
} | |
// Set is the method to set the flag value, part of the flag.Value interface. | |
// Set's argument is a string to be parsed to set the flag. | |
// It's a comma-separated list, so we split it. | |
func (i *interval) Set(value string) error { | |
// If we wanted to allow the flag to be set multiple times, | |
// accumulating values, we would delete this if statement. | |
// That would permit usages such as | |
// -deltaT 10s -deltaT 15s | |
// and other combinations. | |
if len(*i) > 0 { | |
return errors.New("interval flag already set") | |
} | |
for _, dt := range strings.Split(value, ",") { | |
duration, err := time.ParseDuration(dt) | |
if err != nil { | |
return err | |
} | |
*i = append(*i, duration) | |
} | |
return nil | |
} | |
// Define a flag to accumulate durations. Because it has a special type, | |
// we need to use the Var function and therefore create the flag during | |
// init. | |
var intervalFlag interval | |
func init() { | |
// Tie the command-line flag to the intervalFlag variable and | |
// set a usage message. | |
flag.Var(&intervalFlag, "deltaT", "comma-separated list of intervals to use between events") | |
} | |
func main() { | |
// All the interesting pieces are with the variables declared above, but | |
// to enable the flag package to see the flags defined there, one must | |
// execute, typically at the start of main (not init!): | |
// flag.Parse() | |
// We don't run it here because this is not a main function and | |
// the testing suite has already parsed the flags. | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// 显示usage | |
func main() { | |
flag.Parse() | |
if h { | |
flag.Usage() | |
return | |
} | |
cmdName := flag.Arg(0) | |
switch cmdName { | |
case "list": | |
_ = list.Exec(cmdName, flag.Args()[1:]) | |
case "install": | |
_ = install.Exec(cmdName, flag.Args()[1:]) | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// 命令行使用方法: | |
// ./app --parm_name1 name1 --parm_name2 | |
// step1: 定义命令行参数以及接收参数的变量 | |
var ( | |
parm = flag.String("parm_name1", "default_value", "description") | |
parm2 = flag.Bool("parm_name2", false, "it's boolean value") | |
) | |
// step2: | |
flag.Parse() |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
package main | |
import ( | |
"flag" | |
"fmt" | |
"os" | |
) | |
func main() { | |
fooCmd := flag.NewFlagSet("foo", flag.ExitOnError) | |
fooEnable := fooCmd.Bool("enable", false, "enable") | |
fooName := fooCmd.String("name", "", "name") | |
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(" name:", *fooName) | |
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) | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment