Go语言命令行参数解析：flag包的典型应用指南

package main

import (
    "flag"
    "fmt"
)

// 声明变量来存储命令行参数的值，它们都是指针
var (
    namePtr    = flag.String("name", "World", "A name to greet")
    verbosePtr = flag.Bool("v", false, "Enable verbose output")
    countPtr   = flag.Int("c", 1, "Number of times to repeat the greeting")
)

func main() {
    // 在访问参数值之前，必须调用 flag.Parse()
    flag.Parse()

    // 通过解引用指针来获取参数的实际值
    fmt.Printf("Hello, %s!\n", *namePtr)
    if *verbosePtr {
        fmt.Println("Verbose mode is enabled.")
    }
    for i := 0; i < *countPtr; i++ {
        fmt.Printf("Greeting count: %d\n", i+1)
    }
}

go run main.go
# Output:
# Hello, World!
# Greeting count: 1

go run main.go -name GoUser -v -c 3
# Output:
# Hello, GoUser!
# Verbose mode is enabled.
# Greeting count: 1
# Greeting count: 2
# Greeting count: 3

go run main.go -help
# Output:
# Usage of ./main:
#   -c int
#         Number of times to repeat the greeting (default 1)
#   -name string
#         A name to greet (default "World")
#   -v
#         Enable verbose output (default false)

package main

import (
    "flag"
    "fmt"
)

var (
    longStringFlag = flag.String("long-string", "default", "A long string flag description.")
    boolFlag       = flag.Bool("bool-flag", false, "A boolean flag description.")
)

func init() {
    // 为 longStringFlag 设置一个短别名 -s
    // 注意：这里是 StringVar，它将值存储到 longStringFlag 指向的变量中
    flag.StringVar(longStringFlag, "s", "default", "Short version for long-string flag.")

    // 为 boolFlag 设置一个短别名 -b
    flag.BoolVar(boolFlag, "b", false, "Short version for bool-flag.")
}

func main() {
    flag.Parse()

    fmt.Printf("Long String Flag: %s\n", *longStringFlag)
    fmt.Printf("Boolean Flag: %t\n", *boolFlag)
}

go run main.go -long-string "Hello World" -bool-flag
# Output:
# Long String Flag: Hello World
# Boolean Flag: true

go run main.go -s "Short String" -b
# Output:
# Long String Flag: Short String
# Boolean Flag: true

package main

import (
    "flag"
    "fmt"
    "time"
)

var (
    // 声明一个字符串参数，带有长名称和短别名
    message = flag.String("message", "Hello Gopher!", "A message to display.")
    m       = flag.String("m", "", "Short alias for message.") // 短别名，通常在init中绑定到message

    // 声明一个整数参数
    delay = flag.Int("delay", 0, "Delay in seconds before displaying the message.")
    d     = flag.Int("d", 0, "Short alias for delay.")

    // 声明一个布尔参数
    uppercase = flag.Bool("uppercase", false, "Display message in uppercase.")
    u         = flag.Bool("u", false, "Short alias for uppercase.")
)

func init() {
    // 将短别名绑定到对应的长参数变量。
    // 如果同时提供了长参数和短参数，通常以最后解析到的值为准。
    // 更健壮的做法是，如果短别名有值，则优先使用短别名的值。
    // 这里我们直接绑定，让flag包处理冲突（通常是后者的值覆盖前者）。
    // 实际上，更推荐的做法是只声明一次变量，然后用StringVar/BoolVar等函数
    // 将同一个变量绑定到多个flag名。
    // 例如：
    // var msgVal string
    // flag.StringVar(&msgVal, "message", "Hello Gopher!", "A message to display.")
    // flag.StringVar(&msgVal, "m", "Hello Gopher!", "Short alias for message.")
    // 但为了演示，我们先用不同的指针，并在main中处理优先级。
}

func main() {
    flag.Parse()

    // 处理短别名和长参数的优先级
    finalMessage := *message
    if *m != "" { // 如果短别名被设置了值，则优先使用短别名
        finalMessage = *m
    }

    finalDelay := *delay
    if *d != 0 {
        finalDelay = *d
    }

    finalUppercase := *uppercase
    if *u {
        finalUppercase = *u
    }

    if finalDelay > 0 {
        fmt.Printf("Delaying for %d seconds...\n", finalDelay)
        time.Sleep(time.Duration(finalDelay) * time.Second)
    }

    if finalUppercase {
        finalMessage = fmt.Sprintf("%s", finalMessage) // 这里只是一个示例，实际应该使用 strings.ToUpper
        fmt.Println(finalMessage)
    } else {
        fmt.Println(finalMessage)
    }
}

go run main.go -message "Go is awesome" -delay 2 -uppercase
# Output:
# Delaying for 2 seconds...
# GO IS AWESOME

go run main.go -m "Learning Go" -d 1 -u
# Output:
# Delaying for 1 seconds...
# LEARNING GO

go run main.go -m "Override message" -message "Original message"
# Output:
# Override message
# (因为在我们的逻辑中，-m 优先于 -message)