Comment puis-je faire en sorte que plus de deux indicateurs de ligne de commande contrôlent le même comportement ?

En go, je sais comment utiliser l'analyse en ligne de commande de github.com/pborman/getopt包来执行类似getopt.

Cependant, ce package semble ne prendre en charge qu'une seule version de chaîne et une version de rune de chaque option de ligne de commande. Parfois, je veux plus que deux façons de spécifier les options. Par exemple, pour un programme hypothétique appelé prog , j'aimerais que le code suivant remplisse exactement la même fonction :

prog -r [other args]
prog -r [other args]
prog --recurse [other args]
prog --recursive [other args]

Je sais que je peux faire ce qui suit et tester la valeur de chaque variable optrecurse 和 optrecursive...

optrecurse   := getopt.boollong("recurse",   'r', "run recursively")
optrecursive := getopt.boollong("recursive", 'r', "run recursively")

Idéalement, j'aimerais passer un seul appel qui fournit une valeur pour l'une de ces quatre possibilités.

Je voulais quelque chose de similaire au package optionparser de Ruby, où il existe plus de deux possibilités pour une option de ligne de commande donnée. Voici un exemple rubis...

$isRecursive = false
parser = OptionParser.new {
  |opts|
  opts.on('-r', '-R', '--recurse', '--recursive') {
    |arg|
    # All four possibilities are handled with one, single "opts.on" block.
    $isRecursive = true
  }
  # ... etc. ...
}

Je suis relativement nouveau et il y a de fortes chances que j'oublie quelque chose en cherchant une réponse à cette question.

Réponse correcte

À mon avis, il n'y a rien de "bizarre" à fournir plus de deux façons de spécifier une option de ligne de commande donnée.

J'ai initialement mentionné github.com/clagraff/argparse 包不再受支持。然而，我发现了一个更现代且仍然受支持的包，我可以使用它以类似于 ruby 和 python 等其他语言的参数解析包中提供的方式提供确切的功能：github.com/tcler/cmdline -go/cmdline dans cette "réponse".

Voici un exemple de programme montrant comment cela fonctionne en go...

package main                  

import (
    "fmt";
    "os";
    "github.com/tcler/cmdline-go/cmdline";
)

func main() {
    var nargv []string = os.args[1:]
    var cli cmdline.cmdline

    var options = []cmdline.option {
        {help: "options:"},
        {names: "r r recurse recursive", argtype: cmdline.n, help: "run recursively"},
    }

    cli = cmdline.parse(options, nargv)

    has_invalid := false
    for _, v := range cli.invalidoptions {
        if !has_invalid {
            fmt.println()
        }
        fmt.println(v)
        has_invalid = true
    }
    if has_invalid {
        fmt.println()
        cmdline.getusage(options)
        os.exit(1)
    }

    recursivemode := cli.getoptionargstring("r")
    fmt.printf("recursive mode: \"%s\"\n", recursivemode)
}

Je peux exécuter le programme des quatre manières suivantes et il se comporte de la même manière dans chaque cas...

% go run prog.go -r
% go run prog.go -r
% go run prog.go --recurse
% go run prog.go --recursive

Dans les quatre cas, il affiche toujours ce qui suit :

recursive mode: "set"

Si je l'exécute sans aucune option ( c'est-à-dire , juste go run prog.go), il affiche ce qui suit :

recursive mode: ""

Si j'exécute avec d'autres arguments de ligne de commande comme -x, cela échoue comme ceci :

% go run prog.go -x

option: 'x' undefined

Options:
     -r -R --recurse --recursive
                               Run recursively

[ plus some other "help" text ]

Donc, je peux maintenant écrire des programmes go qui permettent de spécifier n'importe quelle option de ligne de commande de plus de deux manières.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!