go处理命令行参数

​

1. 使用 os.Args

os.Args 是Go标准库 os 包中的一个字符串切片（[]string），用于获取命令行参数。os.Args[0] 表示程序本身的名称，后续的元素则是传递给程序的参数。

示例代码

package main

import (
    "fmt"
    "os"
)

func main() {
    // 打印所有命令行参数
    fmt.Println("os.Args:", os.Args)

    // 检查是否有额外的参数
    if len(os.Args) > 1 {
        fmt.Println("传递的参数:")
        for i, arg := range os.Args[1:] {
            fmt.Printf("参数 %d: %s\n", i+1, arg)
        }
    } else {
        fmt.Println("没有传递任何参数。")
    }
}

运行示例

假设编译后的程序名为 example，运行以下命令：

bash

./example hello world 123

输出将会是：

os.Args: [./example hello world 123]
传递的参数:
参数 1: hello
参数 2: world
参数 3: 123

优缺点

优点：​

• 简单易用，适合快速获取命令行参数。

缺点：​

• 需要手动解析参数，缺乏对参数类型、默认值、帮助信息等的支持。
• 不适合处理复杂的命令行选项和子命令。

2. 使用 flag 包

Go语言的 flag 包提供了更强大的命令行参数解析功能，支持定义各种类型的参数、设置默认值、生成帮助信息等。

1. 定义命令行参数：

   • 支持定义多种类型的命令行参数，包括 bool、int、string、float64 等。
   • 支持定义短选项（如 -h）和长选项（如 --help）。

2. 解析命令行参数：

   • 自动解析命令行参数，并将其绑定到定义的变量中。
   • 支持默认值和自定义帮助信息。

3. 获取参数值：

   • 解析后，可以通过定义的变量直接获取命令行参数的值。

4. 错误处理：

   • 自动检测非法参数并输出错误信息。
   • 提供 Usage 函数，用于显示帮助信息。

---

flag 包的基本用法

package main 
 
import (
	"flag"
	"fmt"
)
 
func main() {
	// 定义命令行参数 
	name := flag.String("name", "Guest", "Your name")
	age := flag.Int("age", 0, "Your age")
	verbose := flag.Bool("verbose", false, "Enable verbose mode")
 
	// 解析命令行参数 
	flag.Parse()
 
	// 获取参数值并输出 
	fmt.Printf("Hello, %s!\n", *name)
	fmt.Printf("You are %d years old.\n", *age)
	if *verbose {
		fmt.Println("Verbose mode is enabled.")
	}
}

运行示例：

go run main.go -name=John -age=30 -verbose

输出：

Hello, John!
You are 30 years old.
Verbose mode is enabled.

基本用法2

package main

import (
    "flag"
    "fmt"
)

func main() {
    // 定义命令行参数
    var (
        name    = flag.String("name", "World", "用户的名称")
        age     = flag.Int("age", 0, "用户的年龄")
        married = flag.Bool("married", false, "是否已婚")
        hobbies = flag.String("hobbies", "", "用户的爱好，多个爱好用逗号分隔")
    )

    // 解析命令行参数
    flag.Parse()

    // 使用解析后的参数
    fmt.Printf("Hello, %s!\n", *name)
    fmt.Printf("Age: %d\n", *age)
    fmt.Printf("Married: %v\n", *married)
    if *hobbies != "" {
        fmt.Printf("Hobbies: %s\n", *hobbies)
    } else {
        fmt.Println("No hobbies specified.")
    }

    // 访问非flag参数
    nonFlagArgs := flag.Args()
    if len(nonFlagArgs) > 0 {
        fmt.Println("非flag参数:")
        for i, arg := range nonFlagArgs {
            fmt.Printf("参数 %d: %s\n", i+1, arg)
        }
    } else {
        fmt.Println("没有非flag参数。")
    }
}

运行示例

假设编译后的程序名为 example，运行以下命令：

./example -name=Alice -age=30 -married=true -hobbies=reading,traveling extraArg1 extraArg2

输出将会是：

Hello, Alice!
Age: 30
Married: true
Hobbies: reading,traveling
非flag参数:
参数 1: extraArg1
参数 2: extraArg2

使用自定义类型参数

flag 包允许用户定义自定义类型的命令行参数，通过实现 flag.Value 接口。

package main

import (
    "flag"
    "fmt"
    "strings"
)

// 自定义类型
type StringSlice []string

// 实现 flag.Value 接口的 String 方法
func (s *StringSlice) String() string {
    return fmt.Sprintf("%v", *s)
}

// 实现 flag.Value 接口的 Set 方法
func (s *StringSlice) Set(value string) error {
    *s = append(*s, value)
    return nil
}

func main() {
    var tags StringSlice
    flag.Var(&tags, "tag", "添加一个标签")

    flag.Parse()

    fmt.Println("Tags:", tags)
}

./example -tag=go -tag=programming -tag=awesome

输出将会是：

Tags: [go programming awesome]

生成帮助信息

flag 包自动支持生成帮助信息，用户可以通过 -h 或 --help 参数查看。

./example -h

输出类似如下：

Usage of ./example:
  -age int
        用户的年龄 (default 0)
  -hobbies string
        用户的爱好，多个爱好用逗号分隔
  -married
        是否已婚
  -name string
        用户的名称 (default "World")
  -tag value
        添加一个标签

自定义帮助信息

flag 包默认会生成帮助信息，但可以通过 Usage 函数自定义：

package main 
 
import (
	"flag"
	"fmt"
	"os"
)
 
func main() {
	// 定义命令行参数 
	name := flag.String("name", "Guest", "Your name")
	age := flag.Int("age", 0, "Your age")
	verbose := flag.Bool("verbose", false, "Enable verbose mode")
 
	// 自定义帮助信息 
	flag.Usage = func() {
		fmt.Fprintf(flag.CommandLine.Output(), "Usage of %s:\n", os.Args[0])
		fmt.Println("This is a custom help message.")
		fmt.Println("Available options:")
		flag.PrintDefaults() // 显示默认的帮助信息 
		fmt.Println("Example:")
		fmt.Println("  go run main.go  -name=John -age=30 -verbose")
	}
 
	// 解析命令行参数 
	flag.Parse()
 
	// 获取参数值并输出 
	fmt.Printf("Hello, %s!\n", *name)
	fmt.Printf("You are %d years old.\n", *age)
	if *verbose {
		fmt.Println("Verbose mode is enabled.")
	}
}

go run main.go -h

输出：

Usage of main:
This is a custom help message.
Available options:
  -age int 
        Your age (default 0)
  -name string 
        Your name (default "Guest")
  -verbose 
        Enable verbose mode 
Example:
  go run main.go  -name=John -age=30 -verbose 

---

三、flag 包的高级用法

解析子命令

flag 包本身不支持子命令，但可以通过结合 os.Args 实现：

func main() {
	if len(os.Args) < 2 {
		fmt.Println("Expected 'greet' or 'bye' subcommands")
		os.Exit(1)
	}
 
	switch os.Args[1] {
	case "greet":
		name := flag.String("name", "Guest", "Your name")
		flag.Parse()
		fmt.Printf("Hello, %s!\n", *name)
	case "bye":
		fmt.Println("Goodbye!")
	default:
		fmt.Println("Unknown subcommand:", os.Args[1])
		os.Exit(1)
	}
}

go run main.go greet -name=John

输出：

Hello, John!

---

Go语言的 flag 包是一个轻量级且功能强大的命令行参数解析工具，适用于开发各种命令行工具。

• 对于简单的命令行工具，os.Args 足以满足需求，因其简单易用。
• 对于需要处理复杂参数、提供帮助信息或支持多种数据类型的命令行应用，建议使用 flag 包。
• 如果需要更高级的功能，如子命令、自动补全等，可以考虑使用第三方库，如 cobra 或 urfave/cli。

​