Cobra - How to avoid access global variables in a global variable or init() function

在同一个package中的init()函数是按照所在文件文件名的字母顺序执行的，如果一个文件排在root.go之前，那么在其中字义的<文件名>Cmd全局变量赋值时将不能使用在root.go中初始化并赋值的全局变量（如global flags），同样在其init()函数中也不能使用那些全局变量，如果使用则会报空指针错误。

解决办法：在每个命令文件中定义一个run()函数，在<文件名>Cmd的Run域中调用它。

示例：

在root.go中有个--log persistent flag，其对应全局变量enableLogging，根据enableLogging值的真假为另一个全局变量logger赋值：

var enableLogging bool
var logger *slog.Logger

func init() {
    rootCmd.PersistentFlags().BoolVarP(&enableLogging, "log", "l", true, "Logging information")

    ......

    setDefaultLogger()
}

在insert.go中：

var file string

// insertCmd represents the insert command
var insertCmd = &cobra.Command{
    Use:   "insert",
    Short: "insert command",
    Long:  `A longer description of the insert command.`,
    Run: func(cmd *cobra.Command, args []string) {
        insertRun()
    },
}

func init() {
    rootCmd.AddCommand(insertCmd)
    insertCmd.Flags().StringVarP(&file, "file", "f", "", "Filename to process")
    insertCmd.MarkFlagRequired("file")
}

func insertRun() {
    if file == "" {
        fmt.Println("Need a file to read!")
        return
    }

    _, ok := index[file]
    if ok {
        fmt.Println("Found key:", file)
        delete(index, file)

        // Now, delete it from data
        for i, k := range data {
            if k.Filename == file {
                data = slices.Delete(data, i, i+1)
                break
            }
        }
    }

    err := ProcessFile(file)
    if err != nil {
        fmt.Println(err)
        return
    }

    err = saveJSONFile(JSONFILE)
    if err != nil {
        fmt.Printf("Error saving data: %s", err)
    }
}

func readFile(filepath string) (values []float64, err error) {
    _, err = os.Stat(filepath)
    if err != nil {
        return nil, err
    }

    f, err := os.Open(filepath)
    if err != nil {
        return nil, err
    }
    defer f.Close()

    lines, err := csv.NewReader(f).ReadAll()
    if err != nil {
        return nil, err
    }

    values = make([]float64, 0, len(lines))
    for i, line := range lines {
        value, err4 := strconv.ParseFloat(line[0], 64)
        if err4 != nil {
            logger.Error(fmt.Sprintln("Invalid value", line[0], "in line", i, err4))

            if err == nil {
                err = errors.New("failed to read at least one value")
            }
        }
        values = append(values, value)
    }

    return
}

func ProcessFile(file string) error {
    currentFile := Entry{}
    currentFile.Filename = file

    values, err := readFile(file)
    if err != nil {
        return err
    }

    currentFile.Len = len(values)
    currentFile.Minimum = slices.Min(values)
    currentFile.Maximum = slices.Max(values)
    currentFile.Mean, currentFile.StdDev = stdDev(values)

    data = append(data, currentFile)

    return nil
}