解决Go语言中命令行参数冲突：flag 包的最佳实践与FlagSet应用

// settings/settings.go (不推荐的做法)
package settings

import (
    "flag"
    "fmt"
)

var someSetting = flag.String("setting", "default", "A setting for the package.")

func init() {
    // 避免在非 main 包的 init 函数中调用 flag.Parse()
    // 这可能导致与主程序或测试框架的参数解析冲突
    // flag.Parse() // 移除此行
    fmt.Println("Settings package initialized.")
}

func GetSetting() string {
    // 如果在 main 包中调用了 flag.Parse()，这里可以直接获取值
    // 如果没有，且没有其他地方调用，这里的值可能是默认值
    return *someSetting
}

// mylib/mylib.go
package mylib

import (
    "flag"
    "fmt"
)

var verbose = flag.Bool("verbose", false, "Enable verbose output.")

func init() {
    // init 函数中通常只定义参数，不进行解析
    fmt.Println("mylib package initialized.")
}

func PerformAction() {
    // 假设 main 包或测试框架已经调用了 flag.Parse()
    if !flag.Parsed() {
        fmt.Println("Warning: flags not parsed yet. Using default values.")
        // 可以在这里选择性地调用 flag.Parse()，但需谨慎
        // 再次强调：通常不在这里调用 flag.Parse()，而是依赖外部调用
    }
    if *verbose {
        fmt.Println("Performing action with verbose output.")
    } else {
        fmt.Println("Performing action.")
    }
}

// mytool/mytool.go
package mytool

import (
    "flag"
    "fmt"
    "os"
)

// MyToolFlagSet 定义一个独立的参数集
var MyToolFlagSet = flag.NewFlagSet("mytool", flag.ExitOnError)

// 定义 MyToolFlagSet 专属的参数
var (
    configPath = MyToolFlagSet.String("config", "/etc/mytool.conf", "Path to the configuration file.")
    dryRun     = MyToolFlagSet.Bool("dry-run", false, "Perform a dry run without making changes.")
)

// ParseAndRun 解析并执行工具逻辑
// args 参数通常是 os.Args[1:] 或一个自定义的参数切片
func ParseAndRun(args []string) error {
    // 解析传入的参数，而不是全局的 os.Args[1:]
    err := MyToolFlagSet.Parse(args)
    if err != nil {
        return err
    }

    fmt.Printf("MyTool: Configuration path: %s\n", *configPath)
    fmt.Printf("MyTool: Dry run enabled: %t\n", *dryRun)

    // 处理剩余的非参数参数
    if MyToolFlagSet.NArg() > 0 {
        fmt.Printf("MyTool: Remaining arguments: %v\n", MyToolFlagSet.Args())
    }

    // 实际的工具逻辑
    if *dryRun {
        fmt.Println("MyTool: Dry run complete.")
    } else {
        fmt.Println("MyTool: Executing actual changes...")
    }
    return nil
}

// 示例用法 (通常在 main 包中调用)
/*
package main

import (
    "fmt"
    "os"
    "your_module/mytool" // 替换为你的模块路径
)

func main() {
    // 假设命令行是: go run main.go --config /tmp/test.conf --dry-run file1 file2
    // 传递给 MyToolFlagSet.Parse() 的应该是除去程序名之外的参数
    if err := mytool.ParseAndRun(os.Args[1:]); err != nil {
        fmt.Fprintf(os.Stderr, "Error: %v\n", err)
        os.Exit(1)
    }
}
*/

// worker/worker.go
package worker

import "fmt"

type WorkerConfig struct {
    MaxGoroutines  int
    TimeoutSeconds int
    Verbose        bool
}

type Worker struct {
    config WorkerConfig
}

func NewWorker(cfg WorkerConfig) *Worker {
    return &Worker{config: cfg}
}

func (w *Worker) Start() {
    fmt.Printf("Worker started with MaxGoroutines: %d, Timeout: %d, Verbose: %t\n",
        w.config.MaxGoroutines, w.config.TimeoutSeconds, w.config.Verbose)
    // ... worker logic ...
}

// 示例用法 (在 main 包中)
/*
package main

import (
    "flag"
    "your_module/worker" // 替换为你的模块路径
)

func main() {
    // 定义命令行参数
    maxGoroutines := flag.Int("max-goroutines", 10, "Maximum number of goroutines.")
    timeout := flag.Int("timeout",