Golang命令行参数冲突与管理策略

// package moduleA
package moduleA

import (
    "flag"
    "fmt"
)

// 定义一个私有的 FlagSet
var moduleAFlagSet = flag.NewFlagSet("moduleA", flag.ExitOnError)

// 定义该模块的参数
var (
    ModuleAOption1 string
    ModuleAOption2 int
)

func init() {
    moduleAFlagSet.StringVar(&ModuleAOption1, "a-opt1", "defaultA", "Option 1 for Module A")
    moduleAFlagSet.IntVar(&ModuleAOption2, "a-opt2", 100, "Option 2 for Module A")
    fmt.Println("ModuleA package: Flags defined in FlagSet.")
}

// ParseFlags 允许外部调用者解析 moduleA 的参数
// 通常由 main 包调用，或者在测试中单独调用
func ParseFlags(args []string) error {
    return moduleAFlagSet.Parse(args)
}

// GetOptions 返回模块的配置
func GetOptions() (string, int) {
    return ModuleAOption1, ModuleAOption2
}

// package main
package main

import (
    "flag"
    "fmt"
    "os"
    "your_module/moduleA" // 导入 moduleA 包
)

func main() {
    // 定义 main 包自己的参数
    mainOption := flag.String("main-opt", "defaultMain", "Option for main package")
    flag.Parse() // 解析 main 包和所有全局定义的参数

    fmt.Printf("Main Option: %s\n", *mainOption)

    // 解析 moduleA 的参数
    // 注意：这里需要手动传递 os.Args[1:]，因为 flag.Parse() 已经处理了 os.Args
    // 如果 moduleA 的参数是独立的，可以从 os.Args 中过滤出来，或者设计成只在测试中调用
    // 示例中简化处理，假设 moduleA 的参数直接跟在 main 参数之后
    fmt.Println("Attempting to parse ModuleA flags...")
    // 实际应用中，你可能需要更复杂的逻辑来从 os.Args 中提取属于 moduleA 的参数
    // 这里为了演示，我们假设 moduleA 的参数是 -a-opt1 value -a-opt2 value
    // 并且它们没有被全局 flag.Parse() 消费

    // 在本例中，如果 moduleA 的参数与全局参数格式相同，它们会被 flag.Parse() 消费。
    // 更常见的用法是，FlagSet 在测试中独立使用，或者用于子命令。
    // 例如，模拟一个子命令解析：
    // go run main.go -main-opt value moduleA -a-opt1 value -a-opt2 value

    // 为了演示 FlagSet 的独立性，我们假设有一个独立的参数字符串
    moduleAArgs := []string{"-a-opt1", "customA", "-a-opt2", "200"}
    err := moduleA.ParseFlags(moduleAArgs) // 解析 moduleA 的局部参数
    if err != nil {
        fmt.Printf("Error parsing moduleA flags: %v\n", err)
    }

    opt1, opt2 := moduleA.GetOptions()
    fmt.Printf("ModuleA Option 1: %s\n", opt1)
    fmt.Printf("ModuleA Option 2: %d\n", opt2)

    // 如果是从 os.Args 传递，需要更精细的控制，例如：
    // 如果你希望 moduleA 的参数是独立的，通常会将其设计为子命令模式
    // 例如：go run main.go serve -a-opt1 val
    // 此时，你可以根据 os.Args[1] 来判断子命令，然后将 os.Args[2:] 传递给对应的 FlagSet
    if len(os.Args) > 1 && os.Args[1] == "moduleA-subcommand" {
        fmt.Println("Parsing moduleA subcommand flags...")
        err := moduleA.ParseFlags(os.Args[2:])
        if err != nil {
            fmt.Printf("Error parsing moduleA subcommand flags: %v\n", err)
        }
        opt1, opt2 = moduleA.GetOptions()
        fmt.Printf("ModuleA (subcommand) Option 1: %s\n", opt1)
        fmt.Printf("ModuleA (subcommand) Option 2: %d\n", opt2)
    }
}

// package moduleA_test
package moduleA_test

import (
    "testing"
    "your_module/moduleA" // 导入 moduleA 包
)

func TestModuleAParsing(t *testing.T) {
    // 为测试用例解析独立的参数
    args := []string{"-a-opt1", "testValue", "-a-opt2", "999"}
    err := moduleA.ParseFlags(args)
    if err != nil {
        t.Fatalf("Failed to parse moduleA flags: %v", err)
    }

    opt1, opt2 := moduleA.GetOptions()
    if opt1 != "testValue" {
        t.Errorf("Expected ModuleAOption1 'testValue', got '%s'", opt1)
    }
    if opt2 != 999 {
        t.Errorf("Expected ModuleAOption2 999, got %d", opt2)
    }
}