flag的增强go-flags

type Commander interface {
	// Execute will be called for the last active (sub)command. The
	// args argument contains the remaining command line arguments. The
	// error that Execute returns will be eventually passed out of the
	// Parse method of the Parser.
	Execute(args []string) error
}

func main() {
	SubCommend()
}

func SubCommend() {
	// 创建解析器
	parser := flags.NewParser(&Options{}, flags.Default)

	// 添加子命令
	subCmd1 := &Subcommand1{}
	subCmd2 := &Subcommand2{}

	parser.AddCommand("subcommand1", "子命令1的描述", "子命令1的长描述...", subCmd1)
	parser.AddCommand("subcommand2", "子命令2的描述", "子命令2的长描述...", subCmd2)

	// 解析命令行参数
	_, err := parser.Parse()
	if err != nil {
		os.Exit(1)
	}
}

type Options struct {
	// 主命令的选项
}

type Subcommand1 struct {
	// 子命令1的选项
}

type Subcommand2 struct {
	// 子命令2的选项
}

// Execute 实现子命令的方法
func (opts *Subcommand1) Execute(args []string) error {
	// 子命令1的逻辑
	fmt.Println("执行子命令1")
	fmt.Println("执行子命令1")
	fmt.Println("执行子命令1")
	return nil
}

func (opts *Subcommand2) Execute(args []string) error {
	// 子命令2的逻辑
	fmt.Println("执行子命令2")
	fmt.Println("执行子命令2")
	fmt.Println("执行子命令2")
	return nil
}

func GenerateDoc() {
	var opt Options2 // 创建一个 Options 结构体实例用于存储命令行选项的值

	parser := flags.NewParser(&opt, flags.Default) // 创建一个 go-flags 解析器，并将 Options 结构体的地址传递给它
	parser.Usage = "[MAIN-PARAM]"                  // 设置解析器的用法说明

	opt.Call = func(value string) {
		fmt.Println("in callback: ", value)
	}

	_, err := parser.Parse() // 解析命令行参数，并返回解析结果和可能的错误
	if err != nil {          // 如果解析过程中发生错误
		if flagsErr, ok := err.(*flags.Error); ok && flagsErr.Type == flags.ErrHelp { // 如果是因为用户请求帮助文档
			os.Exit(0) // 立即退出程序，不进行其他处理
		}
		fmt.Println(err) // 打印错误信息
		os.Exit(1)       // 退出程序并返回错误码 1
	}

	// 执行到这里说明命令行参数解析成功，可以执行其他逻辑
	fmt.Printf("int flag: %v\n", opt.IntFlag)
	fmt.Printf("int slice flag: %v\n", opt.IntSlice)
	fmt.Printf("bool flag: %v\n", opt.BoolFlag)
	fmt.Printf("bool slice flag: %v\n", opt.BoolSlice)
	fmt.Printf("float flag: %v\n", opt.FloatFlag)
	fmt.Printf("float slice flag: %v\n", opt.FloatSlice)
	fmt.Printf("string flag: %v\n", opt.StringFlag)
	fmt.Printf("string slice flag: %v\n", opt.StringSlice)
	fmt.Println("slice of pointer of string flag: ")
	for i := 0; i < len(opt.PtrStringSlice); i++ {
		fmt.Printf("\t%d: %v\n", i, *opt.PtrStringSlice[i])
	}
	fmt.Printf("int map: %v\n", opt.IntMap)
}

// Options2 结构体用于定义命令行选项
type Options2 struct {
	IntFlag        int            `short:"i" long:"int" description:"int flag value"`
	IntSlice       []int          `long:"intslice" description:"int slice flag value"`
	BoolFlag       bool           `long:"bool" description:"bool flag value"`
	BoolSlice      []bool         `long:"boolslice" description:"bool slice flag value"`
	FloatFlag      float64        `long:"float" description:"float64 flag value"`
	FloatSlice     []float64      `long:"floatslice" description:"float64 slice flag value"`
	StringFlag     string         `short:"s" long:"string" description:"string flag value"`
	StringSlice    []string       `long:"strslice" description:"string slice flag value"`
	PtrStringSlice []*string      `long:"pstrslice" description:"slice of pointer of string flag value"`
	Call           func(string)   `long:"call" description:"callback"`
	IntMap         map[string]int `long:"intmap" description:"A map from string to int"`
}

// MySQLConfig 结构体表示 MySQL 的配置
type MySQLConfig struct {
	Host     string `long:"mysql-host" description:"MySQL host"`
	Port     int    `long:"mysql-port" description:"MySQL port"`
	Username string `long:"mysql-username" description:"MySQL username"`
	Password string `long:"mysql-password" description:"MySQL password"`
}

// RedisConfig 结构体表示 Redis 的配置
type RedisConfig struct {
	Host     string `long:"redis-host" description:"Redis host"`
	Port     int    `long:"redis-port" description:"Redis port"`
	Password string `long:"redis-password" description:"Redis password"`
}

// Options4 Options3 结构体表示所有选项
type Options4 struct {
	MySQL MySQLConfig `group:"MySQL Options"`
	Redis RedisConfig `group:"Redis Options"`
}

func UseGroup() {
	var opts Options4

	parser := flags.NewParser(&opts, flags.Default)
	parser.Usage = "[OPTIONS]"

	_, err := parser.Parse()
	if err != nil {
		if flagsErr, ok := err.(*flags.Error); ok && flagsErr.Type == flags.ErrHelp {
			parser.WriteHelp(os.Stdout)
			os.Exit(0)
		}
		fmt.Println(err)
		os.Exit(1)
	}

	// 打印 MySQL 配置信息
	fmt.Println("MySQL Configuration:")
	fmt.Printf("Host: %s\n", opts.MySQL.Host)
	fmt.Printf("Port: %d\n", opts.MySQL.Port)
	fmt.Printf("Username: %s\n", opts.MySQL.Username)
	fmt.Printf("Password: %s\n", opts.MySQL.Password)

	// 打印 Redis 配置信息
	fmt.Println("\nRedis Configuration:")
	fmt.Printf("Host: %s\n", opts.Redis.Host)
	fmt.Printf("Port: %d\n", opts.Redis.Port)
	fmt.Printf("Password: %s\n", opts.Redis.Password)
}