Quel est le modèle de conception pour le traitement des arguments de ligne de commande

Question

Si vous écrivez un programme exécutable à partir de la ligne de commande, vous souhaitez souvent de proposer à l'utilisateur plusieurs options ou options, ainsi que, éventuellement, plus d'un argument. J'ai tombé mon chemin à travers de nombreuses fois, mais est-il une sorte de modèle de conception pour une boucle dans args et tourne les fonctions appropriées?

Considérer:

myprogram -f filename -d directory -r regex

Comment vous organisez-vous le code après avoir récupérer les arguments à l'aide de quelque built-ins pour votre langue? (spécifique à la langue des réponses accueilli, si cela vous aide à formuler une réponse)

Answer 1

Je pense que la réponse suivante est plus le long des lignes de ce que vous cherchez:

Vous devriez chercher à appliquer le Pattern Template (Modèle de Méthode dans les "Design Patterns" [Gamma, el al])

Bref, c'est la transformation globale ressemble à ceci:

If the arguments to the program are valid then
    Do necessary pre-processing
    For every line in the input
        Do necessary input processing
    Do necessary post-processing
Otherwise
    Show the user a friendly usage message

En bref, de mettre en œuvre un ConsoleEngineBase classe qui a des méthodes pour:

PreProcess()
ProcessLine()
PostProcess()
Usage()
Main()

Puis de créer un châssis, qui instancie un ConsoleEngine() de l'instance et envoie le Main() message pour le coup d'envoi.

Pour voir un bon exemple de la façon de l'appliquer à une console ou d'un programme en ligne de commande consultez le lien suivant: http://msdn.microsoft.com/en-us/magazine/cc164014.aspx

L'exemple est en C#, mais les idées sont facilement mis en œuvre dans tout autre environnement.

Vous regardez le GetOpt() as juste la partie qui fit dans l'argument de la manipulation (pré-traitement).

Espérons que cette aide.

Answer 2

Je ne sais pas du tout documenté "modèles" pour le traitement.

Je crois que l'une des plus anciennes bibliothèques/Api pour le traitement des arguments est getopt. Googler "getopt" montre beaucoup de l'homme des pages et des liens vers des implémentations.

En général, j'ai une préférences ou les paramètres de service dans mon application que l'argument processeur sait comment communiquer avec. Les Arguments sont alors transformés en quelque chose dans ce service que l'application de requête. Cela pourrait être aussi simple que d'un dictionnaire de paramètres (comme une chaîne de paramètre nommé "nom de fichier").

Answer 3

Vous n'avez pas mentionné le langage, mais pour Java, nous avons adoré Apache Commons CLI . Pour C / C ++, getopt.

Answer 4

Quelques commentaires sur ce...

Tout d'abord, il n'y a aucun modèle en soi, d'écrire un analyseur syntaxique est essentiellement un exercice mécanique, donné à une grammaire, un analyseur peut être facilement généré. Des outils comme le Bison, et ANTLR viennent à l'esprit.

Cela dit, analyseur de générateurs sont généralement les excès de la ligne de commande. Ainsi, le schéma habituel est à l'écrire vous-même (comme d'autres l'ont démontré) à quelques reprises jusqu'à ce que vous tombez malade de traiter avec le détail fastidieux et trouver une bibliothèque pour le faire pour vous.

J'ai écrit un pour C++ qui permet d'économiser un tas d'effort que getopt donne et rend agréable l'utilisation de modèles: TCLAP

Answer 5

En supposant que vous avez un objet "config" que vous souhaitez configurer avec les drapeaux et un analyseur de ligne de commande approprié qui se charge d'analyser la ligne de commande et de fournir un flux constant des options, voici un bloc de pseudocode

 while (current_argument = cli_parser_next()) {
    switch(current_argument) {
        case "f": //Parser strips the dashes
        case "force":
            config->force = true;
            break;
        case "d":
        case "delete":
            config->delete = true;
            break;
        //So on and so forth
        default:
            printUsage();
            exit;
    }
}