如何在Cobra命令中传递参数？避免全局变量的实现方案

我理解你的需求——不想用全局变量，又要把Run里生成的root和value传到PersistentPostRun里。刚好我之前也解决过类似问题，给你几个更优雅的方案：

先贴一下你的原始代码方便对照：

var cfBuild = &cobra.Command{
    Use: "build",
    Short: "Build",
    Run: func(cmd *cobra.Command, args []string) {
        root, value := Build(target)
    },
    PersistentPostRun: func(cmd *cobra.Command, args []string) {
        // 此处需要使用root、value
    }
}

方案1：用Command的Annotations字段存临时数据 #

Cobra的Command自带一个Annotations字段，本质是map[string]string，专门用来存命令相关的临时元数据。如果你的root和value是字符串或能轻松转成字符串，这个方案最省事：

var cfBuild = &cobra.Command{
    Use: "build",
    Short: "Build",
    Run: func(cmd *cobra.Command, args []string) {
        root, value := Build(target)
        // 把值存入Annotations
        cmd.Annotations = map[string]string{
            "root":  root,
            "value": value,
        }
    },
    PersistentPostRun: func(cmd *cobra.Command, args []string) {
        // 从Annotations取出使用
        root := cmd.Annotations["root"]
        value := cmd.Annotations["value"]
        // 这里就可以正常使用两个值了
    }
}

如果是复杂类型（比如自定义结构体），可以用JSON序列化后存储，取出时再反序列化：

import "encoding/json"

// Run函数内
root, value := Build(target)
rootJson, _ := json.Marshal(root)
valueJson, _ := json.Marshal(value)
cmd.Annotations = map[string]string{
    "root":  string(rootJson),
    "value": string(valueJson),
}

// PersistentPostRun函数内
var root YourRootStructType
var value YourValueStructType
json.Unmarshal([]byte(cmd.Annotations["root"]), &root)
json.Unmarshal([]byte(cmd.Annotations["value"]), &value)

注意：实际项目里记得加上错误处理，避免序列化失败导致的问题

方案2：自定义命令结构体（类型安全首选） #

如果不想搞序列化，想要完全类型安全的传递，可以自定义结构体嵌入cobra.Command，同时添加需要存储的字段：

import "github.com/spf13/cobra"

// 自定义命令结构体，嵌入cobra.Command
type BuildCmd struct {
    cobra.Command
    root  YourRootType // 替换成你实际的类型
    value YourValueType // 替换成你实际的类型
}

// 初始化自定义命令
var cfBuild = func() *cobra.Command {
    buildCmd := &BuildCmd{}
    buildCmd.Use = "build"
    buildCmd.Short = "Build"
    
    buildCmd.Run = func(cmd *cobra.Command, args []string) {
        // 将cmd转为自定义的BuildCmd类型
        bc := cmd.(*BuildCmd)
        // 直接把值存在结构体字段中
        bc.root, bc.value = Build(target)
    }
    
    buildCmd.PersistentPostRun = func(cmd *cobra.Command, args []string) {
        bc := cmd.(*BuildCmd)
        // 直接使用bc.root和bc.value，完全类型安全
    }
    
    return &buildCmd.Command
}()

这个方案没有序列化开销，也不用担心类型不匹配，适合复杂类型的场景。

方案3：通过Context传递 #

如果你的项目本身就用context传递上下文，这个方案会很契合。Cobra的Command支持设置和获取Context：

import "context"

// 定义自定义context key，避免和其他包的key冲突
type ctxKey string
const (
    rootCtxKey ctxKey = "build-root"
    valueCtxKey ctxKey = "build-value"
)

var cfBuild = &cobra.Command{
    Use: "build",
    Short: "Build",
    Run: func(cmd *cobra.Command, args []string) {
        root, value := Build(target)
        // 将值存入context，再设置给命令
        newCtx := context.WithValue(cmd.Context(), rootCtxKey, root)
        newCtx = context.WithValue(newCtx, valueCtxKey, value)
        cmd.SetContext(newCtx)
    },
    PersistentPostRun: func(cmd *cobra.Command, args []string) {
        ctx := cmd.Context()
        // 取出值时做类型断言，建议加ok判断避免panic
        if root, ok := ctx.Value(rootCtxKey).(YourRootType); ok {
            if value, ok := ctx.Value(valueCtxKey).(YourValueType); ok {
                // 安全使用root和value
            }
        }
    }
}

这个方案扩展性很好，后续如果要传递其他上下文数据，直接往context里添加即可。

内容的提问来源于stack exchange，提问作者user8557463