主标识和衍生指令

对于一个Golang开发者来说，牢固扎实的基础是十分重要的，golang学习网就来带大家一点点的掌握基础知识点。今天本篇文章带大家了解《主标识和衍生指令》，主要介绍了，希望对大家的知识积累有所帮助，快点收藏起来吧，否则需要时就找不到了！

我正在实现一个带有多个子命令的小型 cli。我想支持全局标志，即适用于所有子命令以避免重复的标志。

例如，在下面的示例中，我尝试使用所有子命令都需要的 -required 标志。

package main

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

var (
    required = flag.string(
        "required",
        "",
        "required for all commands",
    )
    foocmd = flag.newflagset("foo", flag.exitonerror)
    barcmd = flag.newflagset("bar", flag.exitonerror)
)

func main() {
    flag.parse()

    if *required == "" {
        fmt.println("-required is required for all commands")
    }

    switch os.args[1] {
    case "foo":
        foocmd.parse(os.args[2:])
        fmt.println("foo")
    case "bar":
        barcmd.parse(os.args[2:])
        fmt.println("bar")
    default:
        log.fatalf("[error] unknown subcommand '%s', see help for more details.", os.args[1])
    }
}

我希望用法如下：

$ go run main.go foo -required helloworld

但是如果我用上面的代码运行它，我会得到：

$ go run main.go foo -required hello
-required is required for all commands
flag provided but not defined: -required
Usage of foo:
exit status 2

看起来 flag.parse() 没有从 cli 捕获 -required，然后 foocmd 抱怨我给了它一个它无法识别的标志。

在 golang 中使用带有全局标志的子命令的最简单方法是什么？

正确答案

如果您打算实现子命令，则不应调用 flag.Parse()。

而是决定使用哪个子命令（就像您对 os.args[1] 所做的那样），并仅调用其 FlagSet.Parse() 方法。

是的，为此，所有标志集都应包含通用标志。但将它们注册一次（在一个地方）很容易。创建包级别变量：

var (
    required string

    foocmd = flag.newflagset("foo", flag.exitonerror)
    barcmd = flag.newflagset("bar", flag.exitonerror)
)

并使用循环迭代所有标志集，并注册通用标志，使用 FlagSet.StringVar() 指向您的变量：

func setupcommonflags() {
    for _, fs := range []*flag.flagset{foocmd, barcmd} {
        fs.stringvar(
            &required,
            "required",
            "",
            "required for all commands",
        )
    }
}

并在 main() 中调用适当标志集的 parse()，然后测试 required：

func main() {
    setupcommonflags()

    switch os.args[1] {
    case "foo":
        foocmd.parse(os.args[2:])
        fmt.println("foo")
    case "bar":
        barcmd.parse(os.args[2:])
        fmt.println("bar")
    default:
        log.fatalf("[error] unknown subcommand '%s', see help for more details.", os.args[1])
    }

    if required == "" {
        fmt.println("-required is required for all commands")
    }
}

您可以通过创建标志集映射来改进上述解决方案，这样您就可以使用该映射来注册通用标志，并进行解析。

完整应用程序：

var (
    required string

    foocmd = flag.newflagset("foo", flag.exitonerror)
    barcmd = flag.newflagset("bar", flag.exitonerror)
)

var subcommands = map[string]*flag.flagset{
    foocmd.name(): foocmd,
    barcmd.name(): barcmd,
}

func setupcommonflags() {
    for _, fs := range subcommands {
        fs.stringvar(
            &required,
            "required",
            "",
            "required for all commands",
        )
    }
}

func main() {
    setupcommonflags()

    cmd := subcommands[os.args[1]]
    if cmd == nil {
        log.fatalf("[error] unknown subcommand '%s', see help for more details.", os.args[1])
    }

    cmd.parse(os.args[2:])
    fmt.println(cmd.name())

    if required == "" {
        fmt.println("-required is required for all commands")
    }
}

将全局标志放在子命令之前：

go运行。 -required=x foo。

使用flag.args()代替os.args：

package main

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

var (
    required = flag.string(
        "required",
        "",
        "required for all commands",
    )   
    foocmd = flag.newflagset("foo", flag.exitonerror)
    barcmd = flag.newflagset("bar", flag.exitonerror)
)

func main() {
    flag.parse()

    if *required == "" {
        fmt.println("-required is required for all commands")
    }   

    args := flag.args() // everything after the -required flag, e.g. [foo, -foo-flag-1, -foo-flag-2, ...]
    switch args[0] {
    case "foo":
        foocmd.parse(args[1:])
        fmt.println("foo")
    case "bar":
        barcmd.parse(args[1:])
        fmt.println("bar")
    default:
        log.fatalf("[error] unknown subcommand '%s', see help for more details.", args[0])
    }   
}

如果您想将所有标志保留在一起，请在子命令之后编写一个辅助函数，将通用标志添加到每个 flagset：

var (
    fooCmd = flag.NewFlagSet("foo", flag.ExitOnError)
    barCmd = flag.NewFlagSet("bar", flag.ExitOnError)
)

type globalOpts struct {
    required string
}

func main() {
    var opts globalOpts

    addGlobalFlags(fooCmd, &opts)
    addGlobalFlags(barCmd, &opts)

    if opts.required == "" {
        fmt.Println("-required is required for all commands")
    } 

    // ...
}

func addGlobalFlags(fs *flag.FlagSet, opts *globalOpts) {
    fs.StringVar(
        &opts.required,
        "required",
        "",
        "required for all commands",
    )
}

也许您还可以将这两种方法结合起来，使全局标志在任何位置都起作用。

今天关于《主标识和衍生指令》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！