La vie

Utilisation d'OptionParser pour analyser les commandes en Ruby

Utilisation d'OptionParser pour analyser les commandes en Ruby

Dans l'article traitant des fonctionnalités d'OptionParser, nous avons exposé certaines des raisons pour lesquelles il est préférable d'utiliser OptionParser in Ruby plutôt que de parcourir ARGV manuellement pour analyser les commandes à la main. Il est maintenant temps d'apprendre comment utiliser OptionParser et ses fonctionnalités.

Le code standard suivant sera utilisé pour tous les exemples de ce tutoriel. Pour essayer l'un des exemples, il suffit de mettre les exemples opts.on bloquer à côté du commentaire TODO. L'exécution du programme imprimera l'état des options a et ARGV, vous permettant d'examiner les effets de vos commutateurs.

#! / usr / bin / env ruby
nécessite 'optparse'
besoin de 'pp'
# Ce hachage contiendra toutes les options
# analysé à partir de la ligne de commande par
# OptionParser.
options = {}
optparse = OptionParser.new do | opts |
# TODO: Mettez les options de ligne de commande ici
# Ceci affiche l'écran d'aide, tous les programmes sont
# supposé avoir cette option.
opts.on ('-h', '--help', 'Afficher cet écran') faire
met les opts
sortie
fin
fin
# Analyser la ligne de commande. Rappelez-vous qu'il existe deux formes
# de la méthode d'analyse. La méthode 'parse' analyse simplement
# ARGV, tandis que le "parse!" méthode analyse ARGV et supprime
# toutes les options trouvées là-bas, ainsi que tous les paramètres pour
# les options. Ce qui reste est la liste des fichiers à redimensionner.
optparse.parse!
pp "Options:", options
pp "ARGV:", ARGV

Commutateur simple

Un simple commutateur est un argument sans formulaire optionnel ni paramètre. L'effet consistera simplement à définir un indicateur dans le hachage des options. Aucun autre paramètre ne sera transmis à la sur méthode.

options: simple = false
opts.on ('-s', '--simple', "Simple argument") do
options: simple = true
fin

Commutateur avec paramètre obligatoire

Les commutateurs prenant un paramètre doivent uniquement indiquer le nom du paramètre dans sa forme longue. Par exemple, "-f", "--file FILE" signifie que le commutateur -f ou --file prend un seul paramètre appelé FILE, et ce paramètre est obligatoire. Vous ne pouvez utiliser ni -f ni --file sans lui transmettre également un paramètre.

options: mand = ""
opts.on ('-m', '--file obligatoire', "Argument obligatoire") do | f |
options: mand = f
fin

Commutateur avec paramètre optionnel

Les paramètres de commutation ne doivent pas nécessairement être obligatoires, ils peuvent être facultatifs. Pour déclarer un paramètre de commutateur facultatif, placez son nom entre parenthèses dans la description du commutateur. Par exemple, "--logfile FILE" signifie que le paramètre FILE est optionnel. S'il n'est pas fourni, le programme assumera une valeur par défaut raisonnable, telle qu'un fichier appelé log.txt.

Dans l'exemple, l'idiome a = b || c est utilisé. Ceci est juste un raccourci pour "a = b, mais si b est faux ou nul, a = c".

options: opt = false
opts.on ('-o', '--optional OPT', "Argument optionnel") do | f |
options: opt = f || "rien"
fin

Convertir automatiquement en flottant

OptionParser peut convertir automatiquement les arguments en certains types. Un de ces types est Float. Pour convertir automatiquement vos arguments en commutateurs sur Float, passez Float au sur méthode après vos chaînes de description de commutateur.

Les conversions automatiques sont pratiques. Non seulement ils vous sauvegardent l'étape de la conversion de la chaîne dans le type souhaité, mais ils vérifient également le format pour vous et lèveront une exception si le formatage est incorrect.

options: float = 0.0
opts.on ('-f', '--float NUM', Float, "Convertir en float") do | f |
options: float = f
fin

Certains autres types qu'OptionParser peut convertir pour inclure automatiquement Time et Integer.

Listes d'arguments

Les arguments peuvent être interprétés comme des listes. Cela peut être vu comme une conversion en tableau, lorsque vous avez converti en float. Bien que votre chaîne d'options puisse définir le paramètre à appeler "a, b, c", OptionParser autorisera aveuglément un nombre quelconque d'éléments dans la liste. Donc, si vous avez besoin d'un nombre spécifique d'éléments, assurez-vous de vérifier vous-même la longueur du tableau.

options: liste =
opts.on ('-l', '--list a, b, c', Tableau, "Liste de paramètres") do | l |
options: liste = l
fin

Ensemble d'arguments

Parfois, il est judicieux de limiter les arguments à un simple choix. Par exemple, le commutateur suivant ne prendra qu’un seul paramètre obligatoire et ce paramètre doit être l’un des suivants: Oui, non ou peut être. Si le paramètre est autre chose, une exception sera levée.

Pour ce faire, transmettez une liste de paramètres acceptables sous forme de symboles après les chaînes de description du commutateur.

options: set =: yes
opts.on ('-s', '--set OPT',: oui,: non,: peut-être, "Paramètres d'un ensemble") do | s |
options: set = s
fin

Formes Négrées

Les commutateurs peuvent avoir une forme annulée. L'interrupteur - néant peut avoir un qui fait l'effet inverse, appelé - non annulé. Pour décrire cela dans la chaîne de description du commutateur, placez la partie alternative entre parenthèses: - non annulé. Si le premier formulaire est rencontré, true sera passé au bloc et false sera bloqué si le deuxième formulaire est rencontré.

options: neg = false
opts.on ('-n', '--no-négé', "Formes négatives") do | n |
options: neg = n
fin