Manejo de Argumentos de Línea de Comando con `ARGV` en Ruby

Ruby es un lenguaje de programación versátil y fácil de aprender, ideal tanto para principiantes como para desarrolladores experimentados. Una de las características más útiles de Ruby es su capacidad para manejar argumentos de línea de comando, lo que permite a los programas recibir información directamente desde la terminal. En este artículo, exploraremos cómo utilizar `ARGV` para manejar estos argumentos de manera efectiva.

¿Qué es `ARGV`?

`ARGV` es una constante en Ruby que contiene un array de los argumentos pasados al script desde la línea de comando. Cuando ejecutas un script Ruby, puedes pasarle parámetros que el script puede utilizar para modificar su comportamiento o para procesar datos específicos. `ARGV` es la forma en que Ruby accede a esos parámetros.

Ejemplo Básico de Uso de `ARGV`

Para ilustrar cómo funciona `ARGV`, consideremos un ejemplo simple. Supongamos que queremos crear un script que imprima un saludo personalizado basado en el nombre que se pasa como argumento.

# saludo.rb
nombre = ARGV[0] || "Mundo"
puts "¡Hola, #{nombre}!"

En este script, `ARGV[0]` accede al primer argumento pasado al script. Si no se proporciona ningún argumento, se utiliza "Mundo" como valor predeterminado. Para ejecutar este script, puedes usar el siguiente comando en la terminal:

ruby saludo.rb Juan

Esto imprimirá:

¡Hola, Juan!

Manejo de Múltiples Argumentos

Además de manejar un solo argumento, `ARGV` puede gestionar múltiples argumentos. Puedes acceder a cada uno de ellos utilizando índices, o puedes iterar sobre el array completo.

Ejemplo de Múltiples Argumentos

# suma.rb
suma = 0
ARGV.each do |numero|
  suma += numero.to_i
end
puts "La suma es: #{suma}"

En este script, estamos sumando todos los números que se pasan como argumentos. Para ejecutarlo, puedes usar:

ruby suma.rb 1 2 3 4 5

Esto imprimirá:

La suma es: 15

Validación de Argumentos

Es importante validar los argumentos que se pasan a tu script para asegurarte de que son del tipo y formato esperados. Esto puede ayudar a evitar errores y a proporcionar una mejor experiencia al usuario.

Ejemplo de Validación de Argumentos

# validar.rb
if ARGV.length != 2
  puts "Uso: ruby validar.rb  "
  exit
end

nombre = ARGV[0]
edad = ARGV[1].to_i

if edad < 0
  puts "La edad no puede ser negativa."
else
  puts "#{nombre} tiene #{edad} años."
end

En este script, primero verificamos que se hayan pasado exactamente dos argumentos. Si no es así, mostramos un mensaje de uso y salimos del script. Luego, validamos que la edad no sea negativa. Puedes ejecutarlo así:

ruby validar.rb Juan 25

Esto imprimirá:

Juan tiene 25 años.

Uso de Opciones con `ARGV`

Además de argumentos simples, a menudo querrás manejar opciones en tus scripts, como banderas o parámetros con valores. Esto se puede hacer de varias maneras, pero una de las más comunes es usar un enfoque de análisis manual.

Ejemplo de Opciones

# opciones.rb
opciones = {}
ARGV.each do |arg|
  if arg.start_with?("--")
    key = arg[2..-1] # Eliminar el prefijo '--'
    opciones[key] = true
  elsif arg.start_with?("-")
    key = arg[1..-1] # Eliminar el prefijo '-'
    opciones[key] = ARGV[ARGV.index(arg) + 1] if ARGV[ARGV.index(arg) + 1]
  end
end

puts "Opciones: #{opciones}"

En este script, estamos buscando argumentos que comiencen con `--` o `-`. Si encontramos una opción con `--`, la agregamos al hash `opciones` con un valor booleano. Si encontramos una opción con `-`, asumimos que el siguiente argumento es su valor. Puedes ejecutarlo así:

ruby opciones.rb --verbose -o salida.txt

Esto imprimirá:

Opciones: {"verbose"=>true, "o"=>"salida.txt"}

Uso de Gemas para Manejar Argumentos

Si bien `ARGV` es útil para manejar argumentos de línea de comando, hay gemas en Ruby que pueden facilitar este proceso. Una de las más populares es `OptionParser`, que proporciona una forma más estructurada de manejar opciones y argumentos.

Ejemplo con `OptionParser`

# opciones_parser.rb
require 'optparse'

opciones = {}
OptionParser.new do |opts|
  opts.banner = "Uso: opciones_parser.rb [opciones]"

  opts.on("-v", "--verbose", "Mostrar información detallada") do
    opciones[:verbose] = true
  end

  opts.on("-o", "--output FILE", "Especificar archivo de salida") do |file|
    opciones[:output] = file
  end
end.parse!

puts "Opciones: #{opciones}"

En este script, utilizamos `OptionParser` para definir opciones y sus descripciones. Esto hace que el manejo de argumentos sea más claro y fácil de mantener. Puedes ejecutarlo así:

ruby opciones_parser.rb --verbose -o salida.txt

Esto imprimirá:

Opciones: {:verbose=>true, :output=>"salida.txt"}

Conclusión

Manejar argumentos de línea de comando en Ruby con `ARGV` es una habilidad esencial que te permitirá crear scripts más flexibles y útiles. Desde la validación de argumentos hasta el uso de gemas como `OptionParser`, hay muchas maneras de mejorar la interacción de tus programas con el usuario. A medida que continúes explorando Ruby, experimentar con `ARGV` y otras herramientas te ayudará a convertirte en un desarrollador más competente y eficiente.

¡Así que no dudes en probar estos ejemplos y crear tus propios scripts personalizados! La práctica es la clave para dominar cualquier lenguaje de programación.