El documento presenta un tutorial básico de Ruby de 20 minutos. Introduce el uso interactivo de Ruby a través de IRB y muestra ejemplos básicos de código como imprimir "Hola Mundo", operaciones aritméticas y definir métodos. Luego explica conceptos como clases, objetos, métodos y atributos para crear una clase Anfitrión que saluda a personas. Finalmente, mejora la clase para crear un MegaAnfitrión que puede saludar a una persona o lista de personas.

1. Upel - IPM
Profesor: Este Blog y Contenido Fue realizado por:
Eduardo Velasquez Yoelitza Mata
Omar Landaeta
Estiwarl Landaeta
Sección 2
Creación de Web Blog

2. Introducción
Este es un pequeño tutorial de Ruby que no debería tomar más de 20 minutos
completarlo. Se asume que ya tienes instalado Ruby. Si no tienes Ruby funcionando en tu
PC, descárgalo e instálalo antes de comenzar.
Ruby interactivo
Arranca el IRB.
 Si estás usando Mac OS X abre una Terminal y escribe irb, después presiona enter.
 Si estás usando Linux, abre una Terminal y escribe irb, después presiona enter.
 Si estás usando Windows, abre fxri desde la sección Ruby de tu Menú de Inicio.
irb(main):001:0>
Bien, ahora está abierto. ¿Y ahora qué?
Escribe esto: "Hola Mundo"
irb(main):001:0> "Hola Mundo"
=> "Hola Mundo"
¡Ruby te obedeció!
¿Qué fue lo que pasó? ¿Acaso acabamos de escribir el programa “Hola Mundo” más corto
del mundo? No exactamente. La segunda linea sólo es la forma que tiene IRB para
decirnos el resultado de la última expresión evaluada. Si queremos que el programa
escriba “Hola Mundo” necesitamos un poco más:
irb(main):002:0> puts "Hola Mundo"
Hola Mundo
=> nil
puts es el comando básico para escribir algo en Ruby. Pero entonces, ¿qué es ese => nil?
Ese es el resultado de la expresión. puts siempre retorna nil, que es el valor que significa
“absolutamente nada” en Ruby.
Tu calculadora gratis está aquí
Pronto, tenemos suficiente para usar IRB como una calculadora básica:
irb(main):003:0> 3+2
=> 5

3. Tres más dos. Bastante fácil. ¿Y qué tal tres veces dos? Podrías escribirlo, es bastante
corto, pero también podrías subir y simplemente cambiar lo que ya ingresaste. Prueba
presionando la flecha hacia arriba en tu teclado y verifica si aparece la linea con 3+2
escrito. Si es así, puedes usar la flecha hacia la izquierda para posicionarte junto al signo +
y cambiarlo por un *.
irb(main):004:0> 3*2
=> 6
Ahora intentemos tres al cuadrado:
irb(main):005:0> 3**2
=> 9
En Ruby ** es la forma que tienes para decir “elevado al”. ¿Y qué tal si quieres hacer lo
inverso y encontrar la raíz cuadrada de algo?
irb(main):006:0> Math.sqrt(9)
=> 3.0
Bien, esperen, ¿qué fue eso? Si adivinaste, “fue la forma de averiguar la raíz cuadrada de
nueve”, estás en lo cierto. Pero veamos las cosas un poco más de cerca. Antes que nada,
¿qué es Math?
Módulos, agrupa el código por tópicos
Math es un módulo incluido para matemáticas. Los módulos tienen dos roles en Ruby.
Esto muestra uno de sus roles: agrupar métodos similares bajo un nombre familiar. Math
también tiene métodos como sin() y tan().
Después de Math hay un punto. ¿Cuál es la función del punto? El punto es la forma de
identificar al receptor de un mensaje. ¿Qué es un mensaje? En este caso es sqrt(9), que
significa “llama al método sqrt”, abreviación de “square root” (raíz cuadrada) con el
parámetro 9.
El resultado de la llamada a este método es el valor 3.0. Notarás que no es simplemente 3.
Eso es porque la mayoría de las veces la raíz cuadrada de un número no será un número
entero, así que el método siempre retorna un número flotante.
¿Y qué pasa si queremos recordar el resultado de algunas de estas operaciones? Asigna el
resultado a una variable.

4. irb(main):007:0> a = 3 ** 2
=> 9
irb(main):008:0> b = 4 ** 2
=> 16
irb(main):009:0> Math.sqrt(a+b)
=> 5.0
Por más bueno que esté esto de la calculadora, nos estamos alejando del tradicional
mensaje Hola Mundo en el que se supone que los cursos para principiantes deben
enfocarse… así que volvamos a eso.
¿Qué tal si queremos decir “Hola” muchas veces sin cansar nuestros dedos con el teclado?
¡Necesitamos definir un método!
irb(main):010:0> def h
irb(main):011:1> puts "Hola Mundo"
irb(main):012:1> end
=> nil
La expresión def h inicia la definición del método. Le dice a Ruby que estamos definiendo
un método, cuyo nombre es h. La siguiente linea es el cuerpo del método, la misma
expresión que vimos anteriormente: puts "Hola Mundo". Finalmente, la última linea end
la dice a Ruby que terminamos de definir el método. La respuesta de Ruby => nil nos
comunica que él sabe que terminamos de definir el método.
Las breves y repetitivas vidas de un método
Ahora intentemos ejecutar ese método algunas veces:
irb(main):013:0> h
Hola Mundo
=> nil
irb(main):014:0> h()
Hola Mundo
=> nil
Bien, eso fue fácil. Ejecutar un método en Ruby es tan fácil como sólo mencionar su
nombre. Si el método no requiere parámetros para ejecutarse, eso es todo lo que
necesitas. Puedes agregar paréntesis vacíos, pero no son necesarios.
¿Y qué tal si queremos saludar sólo a una persona y no a todo el mundo? Simplemente
redefine h para que tome un nombre como parámetro.

5. irb(main):015:0> def h(nombre)
irb(main):016:1> puts "Hola #{nombre}"
irb(main):017:1> end
=> nil
irb(main):018:0> h("Matz")
Hola Matz
=> nil
Así que eso funciona… pero tomémonos un segundo para ver más en detalle qué es lo que
está sucediendo.
Reservando espacios en un String
¿Qué significa la expresión #{nombre}? Esa es la forma que tiene Ruby para insertar algo
en un String. La expresión entre las llaves es transformada en un String (si todavía no lo es)
y posteriormente sustituida en ese punto del String que la contiene. También puedes usar
esto para asegurarte que el nombre comience con mayúscula:
irb(main):019:0> def h(nombre = "Mundo")
irb(main):020:1> puts "Hola #{nombre.capitalize}"
irb(main):021:1> end
=> nil
irb(main):022:0> h "pedro"
Hola Pedro
=> nil
irb(main):023:0> h
Hola Mundo
=> nil
Algunos otros trucos para destacar. Uno es que otra vez estamos llamando al método sin
utilizar los paréntesis. Si lo que quieres hacer es obvio, los paréntesis son opcionales. El
otro truco es el parámetro por defecto Mundo. Esto significa “si no se provee un nombre,
utiliza el nombre por defecto "Mundo"”.

6. Convirtiéndolo en un Anfitrión
¿Qué hacemos si queremos tener un anfitrión más “en serio”? Uno que recuerde tu
nombre, te dé la bienvenida y te trate con respeto. Puedes querer utilizar un objeto para
eso. Vamos a crear la clase “Anfitrion”.
irb(main):024:0> class Anfitrion
irb(main):025:1> def initialize(nombre = "Mundo")
irb(main):026:2> @nombre = nombre
irb(main):027:2> end
irb(main):028:1> def decir_hola
irb(main):029:2> puts "Hola #{@nombre}"
irb(main):030:2> end
irb(main):031:1> def decir_adios
irb(main):032:2> puts "Adiós #{@nombre}, vuelve pronto."
irb(main):033:2> end
irb(main):034:1> end
=> nil
La nueva palabra clave aquí es class. Esto define una nueva clase llamada Anfitrion y un
par de métodos para esa clase. También toma nota de @nombre. Esta es una variable de
instancia y está disponible para todos los métodos de la clase. Como puedes ver es
utilizada por decir_hola y decir_adios.
¿Así que cómo hacemos para que esta clase Anfitrion nos sea de utilidad? Crea un objeto.
Ahora vamos a crear y usar un objeto anfitrión:
irb(main):035:0> a = Anfitrion.new("Juan")
=> #<Anfitrion:0x16cac @nombre="Juan">
irb(main):036:0> a.decir_hola
Hola Juan
=> nil
irb(main):037:0> a.decir_adios
Adiós Juan, vuelve pronto.
=> nil
Una vez que el objeto a es creado, nos recuerda que el nombre es Juan.
Mmm, ¿y si queremos acceder al nombre directamente?
irb(main):038:0> a.@nombre
SyntaxError: compile error
(irb):52: syntax error
from (irb):52
No, no podemos.

7. Por debajo de la piel del objeto
Las variables de instancia se esconden dentro del objeto. No están tan
escondidas, las puedes ver cuando inspeccionas el objeto, y hay otras
formas de acceder a ellas, pero Ruby es fiel a las buenas costumbres de
la programación orientada a objetos manteniendo los datos lo más
privados posible.
Entonces, ¿qué métodos están disponibles para los objetos Anfitrion?
irb(main):039:0> Anfitrion.instance_methods
=> ["method", "send", "object_id", "singleton_methods",
"__send__", "equal?", "taint", "frozen?",
"instance_variable_get", "kind_of?", "to_a",
"instance_eval", "type", "protected_methods", "extend",
"eql?", "display", "instance_variable_set", "hash",
"is_a?", "to_s", "class", "tainted?", "private_methods",
"untaint", "decir_hola", "id", "inspect", "==", "===",
"clone", "public_methods", "respond_to?", "freeze",
"decir_adios", "__id__", "=~", "methods", "nil?", "dup",
"instance_variables", "instance_of?"]
Bien. Eso es un montón de métodos. Nosotros sólo definimos dos
métodos. ¿Qué es lo que está sucediendo? Bueno, estos son todos los
métodos para los objetos Anfitrion, una lista completa, incluyendo los
que están definidos en las superclases de Anfitrion. Si queremos listar
únicamente los métodos definidos para la clase Anfitrion podemos
pedirle que no incluya sus ancestros pasándole el parámetro false, que
significa que no queremos los métodos definidos por sus ancestros.
irb(main):040:0> Anfitrion.instance_methods(false)
=> ["decir_adios", "decir_hola"]
Ah, hay más cosas como esa. Veamos a qué métodos puede responder
nuestro objeto anfitrión:
irb(main):041:0> a.respond_to?("nombre")
=> false
irb(main):042:0> a.respond_to?("decir_hola")
=> true
irb(main):043:0> a.respond_to?("to_s")
=> true
Así que, sabe decir_hola, y to_s (que significa “convertir algo en un
string”, un método que está definido por defecto para todos los
objetos), pero no reconoce nombre como un método.

8. Modificando clases—Nunca es demasiado tarde
¿Pero qué pasa si quieres poder ver o modificar el nombre? Ruby provee
una forma fácil para permitir acceder a las variables de un objeto.
irb(main):044:0> class Anfitrion
irb(main):045:1> attr_accessor :nombre
irb(main):046:1> end
=> nil
En Ruby, puedes volver a abrir una clase y modificarla. Eso no cambia
objetos que ya existan, pero afecta a los nuevos objetos que puedas
crear. Así que vamos a crear un nuevo objeto y juguemos con su
propiedad @nombre.
irb(main):047:0> a = Anfitrion.new("Pedro")
=> #<Anfitrion:0x3c9b0 @nombre="Pedro">
irb(main):048:0> a.respond_to?("nombre")
=> true
irb(main):049:0> a.respond_to?("nombre=")
=> true
irb(main):050:0> a.decir_hola
Hola Pedro
=> nil
irb(main):051:0> a.nombre="Matilde"
=> "Matilde"
irb(main):052:0> a
=> #<Anfitrion:0x3c9b0 @nombre="Matilde">
irb(main):053:0> a.nombre
=> "Matilde"
irb(main):054:0> a.decir_hola
Hola Matilde
=> nil
El uso de attr_accessor determinó que se definan dos nuevos métodos
por nosotros, nombre para obtener el valor, y nombre= para modificarlo.
Saludando a todo el mundo, ¡MegaAnfitrion no
niega el saludo a nadie!
De todas formas, este anfitrión no es tan interesante, sólo puede
trabajar con una persona a la vez. ¿Qué pasaría si tuviéramos alguna
clase MegaAnfitrion que pudiera saludar al mundo, a una persona, o una
lista completa de personas?
Escribamos esto en un archivo en vez de usar directamente el intérprete
interactivo de Ruby IRB.

9. Para salir de IRB, escribe “quit”, “exit” o simplemente presiona Control-
D.
#!/usr/bin/env ruby
class MegaAnfitrion
attr_accessor :nombres
# Crear el objeto
def initialize(nombres = "Mundo")
@nombres = nombres
end
# Decirle hola a todos
def decir_hola
if @nombres.nil?
puts "..."
elsif @nombres.respond_to?("each")
# @nombres es una lista de algún tipo,
# ¡así que podemos iterar!
@nombres.each do |nombre|
puts "Hola #{nombre}"
end
else
puts "Hola #{@nombres}"
end
end
# Decirle adiós a todos
def decir_adios
if @nombres.nil?
puts "..."
elsif @nombres.respond_to?("join")
# Juntar los elementos de la lista
# usando la coma como separador
puts "Adiós #{@nombres.join(", ")}. Vuelvan pronto."
else
puts "Adiós #{@nombres}. Vuelve pronto."
end
end
end
if __FILE__ == $0
ma = MegaAnfitrion.new
ma.decir_hola
ma.decir_adios
# Cambiar el nombre a "Diego"
ma.nombres = "Diego"
ma.decir_hola
ma.decir_adios
# Cambiar el nombre a un vector de nombres

10. ma.nombres = ["Alberto", "Beatriz", "Carlos",
"David", "Ernesto"]
ma.decir_hola
ma.decir_adios
# Cambiarlo a nil
ma.nombres = nil
ma.decir_hola
ma.decir_adios
end
Guarda este archivo como “ri20min.rb”, y ejecútalo con “ruby
ri20min.rb”. El resultado debería ser:
Hola Mundo
Adiós Mundo. Vuelve pronto.
Hola Diego
Adiós Diego. Vuelve pronto.
Hola Alberto
Hola Beatriz
Hola Carlos
Hola David
Hola Ernesto
Adiós Alberto, Beatriz, Carlos, David, Ernesto. Vuelvan pronto.
...
...
Hay un montón de cosas nuevas en este nuevo ejemplo en las que
podemos echar una mirada más profunda.
Así que, investigando nuestro programa, notarás que las primeras lineas
comienzan con un numeral (#). En Ruby, todo lo que esté detrás de un
numeral es un comentario y es ignorado por el intérprete. La primer
linea del archivo es un caso especial y en los sistemas operativos del
estilo Unix determina cómo ejecutar el archivo. El resto de los
comentarios están únicamente para aportar claridad al significado del
código.

11. Nuestro método decir_hola se ha vuelto un poco más complicado:
# Decirle hola a todos
def decir_hola
if @nombres.nil?
puts "..."
elsif @nombres.respond_to?("each")
# @nombres es una lista de algún tipo,
# ¡así que podemos iterar!
@nombres.each do |nombre|
puts "Hola #{nombre}"
end
else
puts "Hola #{@nombres}"
end
end
Ahora usa el atributo @nombres para tomar decisiones. Si es nil, sólo
imprime tres puntos. No hay razón para saludar a nadie, ¿cierto?
Iterando
Si el objeto @nombres responde al método each, es algo sobre lo que se
puede iterar, así que iteramos entre sus elementos y saludamos a cada
uno de sus integrantes. Finalmente, si @nombres es otra cosa, dejamos
que automáticamente se convierta en un string y usamos el saludo por
defecto.
Veamos ese iterador en más detalle:
@nombres.each do |nombre|
puts "Hola #{nombre}"
end
El método each acepta un bloque de código y lo ejecuta por cada
elemento de la lista, y el código entre do y end es el bloque en sí mismo.
Un bloque es como una función anónima o lambda. La variable entre los
pipes (|) es el parámetro para este bloque.
Lo que sucede es que por cada elemento en la lista, nombre va tomando
su valor y se ejecuta la expresión puts "Hola #{nombre}" con ese nombre.

12. Muchos otros lenguajes de programación manejan la iteración de una
lista usando la clásica sintaxis for, que en C se ve así:
for (i=0; i<cantidad_de_elementos; i++)
{
hacer_algo_con(elementos[i]);
}
Esto funciona, pero no es muy elegante. Necesitas una variable
descartable como i, averiguar la cantidad de elementos de la lista, y
explicar cómo recorrerla. La costumbre Ruby (The Ruby Way) es mucho
más elegante, todos los detalles de infraestructura se ocultan en el
método each, todo lo que necesitas hacer es decirle qué hacer con cada
elemento. Internamente, el método each llamará yield "Alberto",
después yield "Beatriz", después yield "Carlos", y así sucesivamente.
Los bloques, una de las funcionalidades más
potentes de Ruby
El poder real de los bloques se disfruta al trabajar con cosas más
complicadas que las listas. Más allá de manejar los detalles de
infraestructura dentro del método, también puedes manejar la
inicialización, la finalización, y los errores—todos ocultos y simplificados
frente a las preocupaciones del desarrollador.
# Decirle adiós a todos
def decir_adios
if @nombres.nil?
puts "..."
elsif @nombres.respond_to?("join")
# Juntar los elementos de la lista
# usando la coma como separador
puts "Adiós #{@nombres.join(", ")}. Vuelvan pronto."
else
puts "Adiós #{@nombres}. Vuelve pronto."
end
end
El método decir_adios no usa each, en vez de eso se fija si @nombres
responde al método join, y si es así, lo usa. Si no es así, simplemente
imprime la variable como un string. Esta práctica de no preocuparse
sobre el tipo de objeto de una variable, y simplemente depender de los
métodos que esta soporta, es conocida como “Duck Typing”. El beneficio
es que no limita innecesariamente los tipos de variables que son
soportados. Si alguien inventa un nuevo tipo de lista, siempre y cuando
implemente el método join con la misma semántica que otras listas,
todo funcionará como fue planeado.

13. Arrancando el Script
Así que eso es la clase MegaAnfitrion, el resto del archivo sólo llama a
los métodos de la clase. Hy un último truco para tener en cuenta, y es la
linea:
if __FILE__ == $0
__FILE__ es la variable mágica que contiene el nombre del archivo que se
está ejecutando en ese momento. $0 es el nombre del archivo usado
para iniciar el programa. Esta verificación dice “si este es el archivo
principal…”. Esto permite que un archivo sea utilizado como una
biblioteca, y no ejecutar código en ese contexto. Pero si el archivo está
siendo usado como un ejecutable, entonces ejecuta ese código.
Considérate iniciado
Eso es todo en este rápido paseo por Ruby. Hay mucho más por
explorar, las estructuras de control diferentes que ofrece Ruby; el uso e
los bloques y yield; módulos como mixins; y más. Espero que esta
pequeña muestra de Ruby te despierte el interés por saber más.
Si es así, por favor dirígete a nuestra area de Documentación, donde
encontrarás vínculos a cursos y manuales, todos disponibles
gratuitamente en internet.
O si realmente te gustaría sumergirte en un libro, busca en el listado de
libros los títulos disponibles para venta en linea o en tu tienda favorita.