Ruby básico – parte 2

Ruby

Sigo con la segunda parte del segundo capítulo del Pickaxe. Creo que la primer parte de Ruby básico fue bastante extensa (para ser un post de un blog), pero es lógico por haber sido el principio hay mucho por ver. De a poco iré aceitando un poco este tipo de posts para hacerlos de manera dinámica (para no aburrirme) pero intentando plasmar los aprendizajes.

Como comentaba antes, además del libro tenía como referencia los videos de un curso de la U. de Berkeley. Esta vez agregué también un material único del mundo de Ruby: _why’s poignant guide ro ruby.

Veníamos viendo algo básico del lenguaje, variables, strings, hasta Arrays y Hashes. Hoy comenzamos con algo creo que novedoso en Ruby que son los símbolos.

Símbolos en Ruby

Los símbolos en Ruby son algo así como constantes a las que no hay que declarar. Ruby garantiza que su valor es único y siempre será el mismo valor, no se les puede asignar un valor de la manera tradicional :simbolo = "Peanut butter jelly" « Esto genera un error.

Funcionan como un string y se nombran con : como primer caracter de su nombre. Al decir “funcionan como un string” me refiero a que se les puede asignar un nombre y usarlo como un string, pero no tienen las funciones de un string. Según _why, generalmente son usados en situaciones donde necesitas un string pero no lo muestras en pantalla. Aparentemente también se usan como llaves en un hash. Más adelante hay más por ver sobre símbolos.

#!/usr/bin/ruby
 
:fernando
:chunky_bacon
 
puts :fernando
p :chunky_bacon
puts :"Chunky bacon!!"

Imprime:

[fernando@hoth pickaxe]$ ./symbols.rb
fernando
:chunky_bacon
Chunky bacon!!

Pequeño intervalo homenajeando a _why

Estructuras de control

Ruby cuenta con las estructuras de control básicas de todo lenguaje de programación. Como esta parte es bastante básica, simplemente pego código de cómo se arma cada estructura para tener como referencia.

#!/usr/bin/ruby
 
hoy = Time.now
 
#Estructura if-else
if hoy.saturday?
  puts "Tiempo de estudiar Ruby"
elsif hoy.sunday?
  puts "Ir a la playa"
else
  puts "Hay que trabajar"
end
 
#Estructura while
num = 99
while num < 0
  puts "#{num} bottles of beer on the wall,"
  puts "#{num} bottles of beer"
  puts "Take one down and pass it around,"
  num -= 1
  puts "#{num} bottles of beer on the wall."
end
 
#Statement modifiers:
puts "Me voy a la playa" if Time.now.sunday?
 
num = 6
puts num = num -1 while num > 1

Expresiones regulares

En Picando Código ya publiqué 10 razones para aprender y usar expresiones regulares. Así que asumo que todos los lectores saben qué son y para qué sirven las expresiones regulares.

Por lo que he aprendido hasta el momento, en Ruby las expresiones regulares se representan entre barras: /expresión regular/. Nada nuevo para la mayoría. Para comparar una cadena de caracteres con una expresión regular se usa el “match operator”: =~. Éste retorna la posición inicial del patrón en la cadena de caracteres.

#!/usr/bin/jruby
# -*- coding: utf-8 -*-
 
regla1 = "You do not talk about Fight Club"
 
puts regla1 =~ /[0-9]/ #nil si no encuentro nada...
 
if regla1 =~ /Fight Club/
  puts "Someone has been talking 'bout it"
end

Creo que gané un par de geek points extra por probar este código con JRuby 😛

Bloques e Iteradores

Se viene todo un tema, algo bastante particular y poderoso del lenguaje. Nada asegura que ya haya asimilado correctamente su concepto, pero comparto con ustedes lo que entiendo.

Los bloques en Ruby, son una porción de código entre llaves {} o do y end. Se pueden asociar a la invocación de un método escribiéndolos enseguida después de la llamada a un método. Definiendo: la forma de asociar un bloque a un método, es escribiéndolos inmediatamente después de la llamada a dicho método.

Ahora, un método puede invocar su bloque asociado con el comando yield. En este concepto, creo que la incisiva guía de _why explica de forma totamente comprensible de qué se trata. En inglés los símbolos de “Ceda el paso” en el tránsito dicen “Yield”:

Puedes preguntarte qué tiene que ver la palabra yield con los carteles de tránsito. Y realmente, es una buena pregunta con, creo yo, una buena respuesta. Cuando ejecutas un método, le estás dando a ese método el control de tu programa. Control para hacer su trabajo y volver con una respuesta.

Con yield, el método se está deteniendo en la intersección, devolviendote el control, a tu bloque. El método está permitiéndote hacer t trabajo antes de resumir el suyo.

Esas pequeñas fases de iluminación… Podemos usar yield las veces que queramos dentro de un método. Cada vez que lo usemos, el método llamará a su bloque asociado.

Los bloques también pueden recibir parámetros. Los parámetros son variables encerradas en pipes y separadas por una coma: |arg1,arg2|.

Código obligado haciendo pruebas de bloques:

#!/usr/bin/ruby
# -*- coding: utf-8 -*-
 
def metodo (name)
  print "Dentro del método: #{name} - "
  yield(name)
end
 
#Bloque en línea simple:
metodo("Mario") { puts "Bloque en línea simple"}
 
#Bloque en varias líneas:
metodo("Pitágoras") do
  puts "Bloque en varias líneas"
  puts 1 * 1
  puts 11 * 11
  puts 111 * 111
  puts 1111 * 1111
  puts 11111 * 11111
end
 
metodo("Armando") {|name| puts "Como parámetro del bloque: #{name}"}

Los bloques se usan en Ruby para implementar iteradores – métodos que devuelven elementos sucesivos de una colección. Creo que el código en este caso es bastante explicativo:

#!/usr/bin/ruby
 
avengers = %w{ Iron\ Man Hulk Thor Captain\ America Wasp Ant-Man }
 
42.times { print "*"}
puts
 
avengers.each {|name| puts "#{name}"}
 
42.times { print "*"}
puts

Lectura y escritura

De los últimos temas del segundo capítulo del libro de Pickaxe, es lectura y escritura. El libro cubre por ahora la entrada y salida estándar. Las funciones:

• puts – Imprime en la salida estándar con un salto de línea.
• print – ídem pero sin salto de línea. Ambos pueden usarse para escribir en cualquier objeto de entrada/salida.
• printf – Imprime con el control de un string de formato (como en C, Perl o PHP): %s, %d, etc.

En cuanto a la lectura, el método tradicional es gets. Éste retorna la siguiente línea de la entrada estándar.

Argumentos desde la línea de comando

Para terminar este post, vamos a ver cómo usar los argumentos pasados a nuestro script Ruby desde la línea de comando. El array ARGV contiene todos los parámetros que pasemos por comandos, y ARGF es un objeto especial de tipo Entrada/Salida que se comporta como los contenidos de los archivos cuyos nombres se pasen por parámetros.

#!/usr/bin/ruby
# -*- coding: utf-8 -*-
 
num = ARGV.size
puts "Parámetros: #{num}"
ARGV.each {|arg| puts "#{arg}"}

Prueben algún código con ARGV y ejecútenlo desde la línea de comandos pasándole varios parámetros.

Y ahí va la segunda parte de este proceso de aprender Ruby. Ya la próxima arrancamos con la interacción entre objetos. Para el próximo post, seguramente vaya mas rápido, ya que no voy a ponerme a definir conceptos básicos de orientación a objetos, solo particularidades de Ruby.