Gestion des Arguments de Ligne de Commande avec `ARGV` en Ruby

Ruby est un langage de programmation puissant et flexible, souvent utilisé pour le développement web, l'automatisation des tâches et bien plus encore. L'un des aspects les plus pratiques de Ruby est sa capacité à gérer les arguments de ligne de commande, ce qui permet aux développeurs de créer des scripts interactifs et dynamiques. Dans cet article, nous allons explorer comment utiliser `ARGV`, un tableau spécial en Ruby qui contient les arguments passés à un script depuis la ligne de commande.

Qu'est-ce que `ARGV` ?

`ARGV` est un tableau en Ruby qui stocke tous les arguments passés à un script lors de son exécution. Par exemple, si vous exécutez un script avec des arguments, ces derniers seront accessibles via `ARGV`. Cela permet aux utilisateurs de personnaliser le comportement du script sans avoir à modifier le code source.

Comment utiliser `ARGV`

Pour illustrer l'utilisation de `ARGV`, commençons par un exemple simple. Supposons que nous avons un script Ruby qui prend un nom en argument et affiche un message de bienvenue. Voici comment cela pourrait être fait :

# welcome.rb
nom = ARGV[0] || "Invité"
puts "Bienvenue, #{nom}!"

Dans cet exemple, nous accédons au premier argument passé au script avec `ARGV[0]`. Si aucun argument n'est fourni, nous utilisons "Invité" comme valeur par défaut.

Exécution du Script

Pour exécuter ce script, vous pouvez ouvrir votre terminal et taper la commande suivante :

ruby welcome.rb Alice

La sortie sera :

Bienvenue, Alice!

Si vous exécutez le script sans argument :

ruby welcome.rb

La sortie sera :

Bienvenue, Invité!

Accéder à Plusieurs Arguments

Vous pouvez également accéder à plusieurs arguments en utilisant `ARGV`. Voici un exemple qui prend deux arguments : un prénom et un nom de famille :

# full_name.rb
prenom = ARGV[0] || "Invité"
nom_de_famille = ARGV[1] || "Inconnu"
puts "Bienvenue, #{prenom} #{nom_de_famille}!"

Pour exécuter ce script, utilisez la commande suivante :

ruby full_name.rb Alice Dupont

La sortie sera :

Bienvenue, Alice Dupont!

Itération sur les Arguments

Il est également possible d'itérer sur tous les arguments passés au script. Voici un exemple qui affiche chaque argument sur une nouvelle ligne :

# list_args.rb
ARGV.each do |arg|
  puts "Argument : #{arg}"
end

Si vous exécutez ce script avec plusieurs arguments :

ruby list_args.rb un deux trois

La sortie sera :

Argument : un
Argument : deux
Argument : trois

Gestion des Erreurs

Lorsque vous travaillez avec des arguments de ligne de commande, il est important de gérer les erreurs. Par exemple, vous pouvez vérifier si le bon nombre d'arguments a été fourni avant de continuer. Voici un exemple :

# check_args.rb
if ARGV.length != 2
  puts "Erreur : Vous devez fournir exactement deux arguments."
  puts "Usage : ruby check_args.rb  "
  exit
end

arg1 = ARGV[0]
arg2 = ARGV[1]
puts "Vous avez fourni : #{arg1} et #{arg2}."

Si vous exécutez ce script sans fournir deux arguments, vous obtiendrez un message d'erreur clair :

ruby check_args.rb

La sortie sera :

Erreur : Vous devez fournir exactement deux arguments.
Usage : ruby check_args.rb

Utilisation de `OptionParser` pour des Arguments Plus Complexes

Pour des scripts plus complexes, vous pouvez utiliser la bibliothèque `OptionParser` qui fait partie de la bibliothèque standard de Ruby. Cela vous permet de gérer des options et des arguments de manière plus structurée. Voici un exemple :

# options.rb
require 'optparse'

options = {}
OptionParser.new do |opts|
  opts.banner = "Usage: options.rb [options]"

  opts.on("-nNAME", "--name=NAME", "Votre nom") do |name|
    options[:name] = name
  end

  opts.on("-aAGE", "--age=AGE", "Votre âge") do |age|
    options[:age] = age
  end
end.parse!

puts "Nom : #{options[:name]}" if options[:name]
puts "Âge : #{options[:age]}" if options[:age]

Pour exécuter ce script avec des options, vous pouvez utiliser :

ruby options.rb --name Alice --age 30

La sortie sera :

Nom : Alice
Âge : 30

Conclusion

Dans cet article, nous avons exploré comment gérer les arguments de ligne de commande en Ruby à l'aide de `ARGV`. Nous avons vu comment accéder à des arguments, itérer sur eux, gérer les erreurs et utiliser `OptionParser` pour des options plus complexes. La gestion des arguments de ligne de commande est une compétence essentielle pour tout développeur Ruby, car elle permet de rendre vos scripts plus flexibles et interactifs.

Que vous soyez un débutant ou un développeur expérimenté, comprendre comment utiliser `ARGV` et `OptionParser` vous aidera à créer des applications Ruby plus robustes et conviviales. N'hésitez pas à expérimenter avec ces concepts dans vos propres projets et à découvrir tout ce que Ruby a à offrir !