Go命令行

var strIpt = flag.String("string", "John", "字符串输入")
var intIpt = flag.Int("int", 1, "int输入")
var int64Ipt = flag.Int64("int64", 1, "int64输入")
var float64Ipt = flag.Float64("float64", 1, "float64输入")

var boolIpt = flag.Bool("bool", false, "bool输入")
var durationIpt = flag.Duration("duration", time.Second, "duration输入")

// test with: go run main.go --string "i'm liming" --int 50 --bool=false -duration 1h30m
func ShowSimplePtr() {
	flag.Parse()
	inputArr := [...]interface{}{strIpt, intIpt, int64Ipt, float64Ipt, boolIpt, durationIpt}
	for _, item := range inputArr {
		val := reflect.ValueOf(item)
		fmt.Printf("input flag type: %T ; input value: %v. \n", item, val.Elem())
	}
}

// go run main.go --strval liming -s danny
// go run main.go --s liming -strval danny
// 变量赋值方法：StringVal, BoolVar, DurationVal, Float64Val, Int64Val, IntVal, Uint64Val, UintVal

func ShowCustomVar() {
	var strValIpt string
	const (
		defaultValue = "slay"
		usage        = "这是一段使用说明"
	)
	flag.StringVar(&strValIpt, "strval", defaultValue, usage)
	flag.StringVar(&strValIpt, "s", defaultValue, usage+" (shorthand)")

	flag.Parse()
	fmt.Printf("input flag type: %T ; input value: %v. \n", strValIpt, strValIpt)
}

// go run main.go --ip=127.0.0.1
func ShowHookFunc() {
	var ip net.IP
	flag.Func("ip", "IP address to parse", func(s string) error {
		ip = net.ParseIP(s)
		if ip == nil {
			return errors.New("parse IP failed")
		}
		return nil
	})

	flag.Parse()
	fmt.Printf("input flag type: %T ; input value: %v. \n", ip, ip)
}

// go run main.go --string liming --bool --int 20
// type Flag struct {
// 	Name     string // name as it appears on command line
// 	Usage    string // help message
// 	Value    Value  // value as set
// 	DefValue string // default value (as text); for usage message
// }
func ShowComplexHook() {
	flag.Parse()

	flag.Visit(func(f *flag.Flag) {
		fmt.Printf("flag name: %v, value: %v \n", f.Name, f.Value)
		switch f.Name {
		case "string":
			f.Value.Set("xiaohong")
		case "int":
			intIpt := f.Value.String()
			strictInt, _ := strconv.Atoi(intIpt)
			strictInt *= 10
			f.Value.Set(strconv.Itoa(strictInt))
		}
	})
	// flag.VisitAll(fn func(*Flag)) 可以遍历所有的标志参数（包括未被设置的）

	strFlagPtr := flag.Lookup("string")
	fmt.Printf("flagPtr : %#v \n", strFlagPtr)

	intFlagPtr := flag.Lookup("int")
	fmt.Printf("flagPtr : %v \n", intFlagPtr)
}

// go run main.go --string liming today --int 50 --bool=false -duration 1h30m hel
func ShowArgs() {
	flag.Parse()
	// 返回非标志命令行参数（返回格式：字符串数组）
	nonFlag := flag.Args()
	fmt.Println(nonFlag)

	secParam := flag.Arg(1)
	fmt.Println(secParam)

	notFlagNum := flag.NArg()
	fmt.Println(notFlagNum)

	// go run main.go --string liming --int 50 --bool=false -duration 1h30m hel
	flagNum := flag.NFlag()
	fmt.Println(flagNum)
}

// FlagSet 提供了定义独立标志集的功能
// const (
// 	ContinueOnError ErrorHandling = iota // Return a descriptive error.
// 	ExitOnError                          // Call os.Exit(2) or for -h/-help Exit(0).
// 	PanicOnError                         // Call panic with a descriptive error.
// )

// go run main.go foo --name=kity --enable x y z
// go run main.go bar --level 9 10 11
func ShowFlagSet() {
	fooCmd := flag.NewFlagSet("foo", flag.ExitOnError)
	fooEnable := fooCmd.Bool("enable", false, "enable")
	fooName := fooCmd.String("name", "", "name")

	// fooCmd.PrintDefaults()

	barCmd := flag.NewFlagSet("bar", flag.ContinueOnError)
	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)
	}
}

func Command() {
	app := &cli.App{
		Commands: []*cli.Command{
			{
				Name:    "add",
				Aliases: []string{"a"},
				Usage:   "add a task to the list",
				Action: func(c *cli.Context) error {
					fmt.Println("added task: ", c.Args().First())
					return nil
				},
			},
			{
				Name:    "complete",
				Aliases: []string{"c"},
				Usage:   "complete a task on the list",
				Action: func(c *cli.Context) error {
					fmt.Println("completed task: ", c.Args().First())
					return nil
				},
			},
			{
				Name:    "template",
				Aliases: []string{"t"},
				Usage:   "options for task templates",
				Subcommands: []*cli.Command{
					{
						Name:  "add",
						Usage: "add a new template",
						Action: func(c *cli.Context) error {
							fmt.Println("new task template: ", c.Args().First())
							return nil
						},
					},
					{
						Name:  "remove",
						Usage: "remove an existing template",
						Action: func(c *cli.Context) error {
							fmt.Println("removed task template: ", c.Args().First())
							return nil
						},
					},
				},
			},
		},
	}

	err := app.Run(os.Args)
	if err != nil {
		log.Fatal(err)
	}
}