Best Practices for Handling Many Optional Flags

Getting Help
1

I’m building a Go CLI application using Cobra and Viper libraries with numerous optional flags (10+). My primary goal is to execute actions only when their corresponding flags are specifically provided by the user.

I’ve tried follwoing approach: Utilizing cmd.Flags().StringVar(flagVar, flagName, defaultValue, usage) and cmd.Flag(“flagName”).Changed

Concerns:

  • Repetition of flag names.
  • Implicit binding between flagName and flagVariable.

I’ve explored an option to use viper.BindPFlag and viper.IsSet, but it hasn’t given an answer to any of my concerns, and it feels like overkill for this relatively simple task.

Mitigations Considered:

  • Constants/Enum for Flag Names: Lessens typos, but mismatches could still occur.
  • Dedicated Flag Management Class: Potentially over-engineered for this use case.

Question:

Are there established Go patterns for managing a substantial number of optional flags that:

  • Minimize the need to repeat flag names (reducing error potential)?
  • Promote maintainability without introducing unnecessary complexity?

Looking for some lib to address these issues (or porper use of cobra/viper that I’m missing).

2

I unfortunately don’t have a lot of experience in this space (I use Go primarily for web APIs and CLI tools without too many optional flags usually). My only thought here is: maybe you could see how a complex project like the GitHub CLI is managing flags. Check this out for example:

And the nested commands live in pkg/cmd. You could go spelunking through that code to get ideas. You could also take a look at how Docker is dealing with a large amount of flags.

Other thoughts: you could potentially leverage struct tags. There are quite a few projects out there that do this for you but it’s not hard to roll your own. Take a look at this project for inspiration (or just add that as a dependency!).

3

Certainly! For managing a large number of optional flags in your Go CLI application:

Define constants for flag names to reduce typos and ensure consistency.
Group related flags under a single struct for easier management.
Consider using subcommands instead of flags for multiple actions.
Encapsulate flag logic in functions or methods for modularization.
Use flag presets for commonly used flag combinations.
As for libraries, Cobra and Viper are solid choices for building CLI applications in Go. They offer robust features for flag management and configuration parsing.