1

Introduccin RUBY
Este es un pequeo tutorial de Ruby que no debera tomar ms de 20 minutos completarlo. Se asume
que ya tienes instalado Ruby. Si no tienes Ruby funcionando en tu PC, descrgalo e instlalo antes de
comenzar.
Ruby interactivo
Arranca el IRB.
Si ests usando Mac OS X abre una Terminal y escribe irb, despus presiona enter.
Si ests usando Linux, abre una Terminal y escribe irb, despus presiona enter.
Si ests usando Windows, abre fxri desde la seccin 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 ms corto del mundo?
No exactamente. La segunda linea slo es la forma que tiene IRB para decirnos el resultado de la ltima
expresin evaluada. Si queremos que el programa escriba Hola Mundo necesitamos un poco ms:
irb(main):002:0> puts "Hola Mundo"
Hola Mundo
=> nil
puts es el comando bsico para escribir algo en Ruby. Pero entonces, qu es ese => nil? Ese es el
resultado de la expresin. 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 bsica:
irb(main):003:0> 3+2
=> 5
Tres ms dos. Bastante fcil. Y qu tal tres veces dos? Podras escribirlo, es bastante corto, pero
tambin podras subir y simplemente cambiar lo que ya ingresaste. Prueba presionando laflecha hacia
arriba en tu teclado y verifica si aparece la linea con3+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 raz cuadrada de algo?
2

irb(main):006:0> Math.sqrt(9)
=> 3.0
Bien, esperen, qu fue eso? Si adivinaste, fue la forma de averiguar la raz cuadrada de nueve, ests
en lo cierto. Pero veamos las cosas un poco ms de cerca. Antes que nada, qu es Math?
Mdulos, agrupa el cdigo por tpicos
Math es un mdulo incluido para matemticas. Los mdulos tienen dos roles en Ruby. Esto muestra uno
de sus roles: agrupar mtodos similares bajo un nombre familiar. Math tambin tiene mtodos
comosin() y tan().
Despus de Math hay un punto. Cul es la funcin 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
mtodosqrt, abreviacin de square root (raz cuadrada) con el parmetro9.
El resultado de la llamada a este mtodo es el valor 3.0. Notars que no es simplemente 3. Eso es
porque la mayora de las veces la raz cuadrada de un nmero no ser un nmero entero, as que el
mtodo siempre retorna un nmero flotante.
Y qu pasa si queremos recordar el resultado de algunas de estas operaciones? Asigna el resultado a
una variable.
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

Qu tal si queremos decir Hola muchas veces sin cansar nuestros dedos con el teclado? Necesitamos
definir un mtodo!
irb(main):010:0> def h
irb(main):011:1> puts "Hola Mundo"
irb(main):012:1> end
=> nil
La expresin def h inicia la definicin del mtodo. Le dice a Ruby que estamos definiendo un mtodo,
cuyo nombre es h. La siguiente linea es el cuerpo del mtodo, la misma expresin que vimos
anteriormente: puts "Hola Mundo". Finalmente, la ltima linea end la dice a Ruby que terminamos de
definir el mtodo. La respuesta de Ruby => nil nos comunica que l sabe que terminamos de definir el
mtodo.
Las breves y repetitivas vidas de un mtodo
Ahora intentemos ejecutar ese mtodo algunas veces:
3

irb(main):013:0> h
Hola Mundo
=> nil
irb(main):014:0> h()
Hola Mundo
=> nil
Bien, eso fue fcil. Ejecutar un mtodo en Ruby es tan fcil como slo mencionar su nombre. Si el
mtodo no requiere parmetros para ejecutarse, eso es todo lo que necesitas. Puedes agregar
parntesis vacos, pero no son necesarios.
Y qu tal si queremos saludar slo a una persona y no a todo el mundo? Simplemente redefine h para
que tome un nombre como parmetro.
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 tommonos un segundo para ver ms en detalle qu es lo que est
sucediendo.
Reservando espacios en un String
Qu significa la expresin #{nombre}? Esa es la forma que tiene Ruby para insertar algo en un String. La
expresin entre las llaves es transformada en un String (si todava no lo es) y posteriormente sustituida
en ese punto del String que la contiene. Tambin puedes usar esto para asegurarte que el nombre
comience con mayscula:
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 mtodo sin utilizar los
parntesis. Si lo que quieres hacer es obvio, los parntesis son opcionales. El otro truco es el parmetro
por defecto Mundo. Esto significa si no se provee un nombre, utiliza el nombre por defecto "Mundo".
Convirtindolo en un Anfitrin
4

Qu hacemos si queremos tener un anfitrin ms 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 "Adis #{@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 mtodos
para esa clase. Tambin toma nota de @nombre. Esta es una variable de instancia y est disponible para
todos los mtodos de la clase. Como puedes ver es utilizada pordecir_hola y decir_adios.
As que cmo hacemos para que esta clase Anfitrion nos sea de utilidad? Crea un objeto.
Ahora vamos a crear y usar un objeto anfitrin:
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
Adis 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.
Por debajo de la piel del objeto
Las variables de instancia se esconden dentro del objeto. No estn 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 programacin orientada a objetos manteniendo los datos lo ms privados posible.
5

Entonces, qu mtodos estn 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 montn de mtodos. Nosotros slo definimos dos mtodos. Qu es lo que est
sucediendo? Bueno, estos son todoslos mtodos para los objetos Anfitrion, una lista completa,
incluyendo los que estn definidos en las superclases de Anfitrion. Si queremos listar nicamente los
mtodos definidos para la clase Anfitrion podemos pedirle que no incluya sus ancestros pasndole el
parmetrofalse, que significa que no queremos los mtodos definidos por sus ancestros.
irb(main):040:0> Anfitrion.instance_methods(false)
=> ["decir_adios", "decir_hola"]
Ah, hay ms cosas como esa. Veamos a qu mtodos puede responder nuestro objeto anfitrin:
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 mtodo que est definido
por defecto para todos los objetos), pero no reconoce nombre como un mtodo.
Modificando clasesNunca es demasiado tarde
Pero qu pasa si quieres poder ver o modificar el nombre? Ruby provee una forma fcil 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.
6

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 mtodos 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 anfitrin no es tan interesante, slo puede trabajar con una persona a la vez.
Qu pasara si tuviramos 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 intrprete interactivo de Ruby IRB.
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")
7


# @nombres es una lista de algn tipo,
# as que podemos iterar!
@nombres.each do |nombre|
puts "Hola #{nombre}"
end
else
puts "Hola #{@nombres}"
end
end

# Decirle adis 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 "Adis #{@nombres.join(", ")}. Vuelvan pronto."
else
puts "Adis #{@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
ma.nombres = ["Alberto", "Beatriz", "Carlos",
"David", "Ernesto"]
ma.decir_hola
ma.decir_adios

# Cambiarlo a nil
ma.nombres = nil
ma.decir_hola
8

ma.decir_adios
end
Guarda este archivo como ri20min.rb, y ejectalo con ruby ri20min.rb. El resultado debera ser:
Hola Mundo
Adis Mundo. Vuelve pronto.
Hola Diego
Adis Diego. Vuelve pronto.
Hola Alberto
Hola Beatriz
Hola Carlos
Hola David
Hola Ernesto
Adis Alberto, Beatriz, Carlos, David, Ernesto. Vuelvan pronto.
...
...
Hay un montn de cosas nuevas en este nuevo ejemplo en las que podemos echar una mirada ms
profunda.
As que, investigando nuestro programa, notars que las primeras lineas comienzan con un numeral (#).
En Ruby, todo lo que est detrs de un numeral es un comentario y es ignorado por el intrprete. La
primer linea del archivo es un caso especial y en los sistemas operativos del estilo Unix determina cmo
ejecutar el archivo. El resto de los comentarios estn nicamente para aportar claridad al significado del
cdigo.
Nuestro mtodo decir_hola se ha vuelto un poco ms complicado:
# Decirle hola a todos
def decir_hola
if @nombres.nil?
puts "..."
elsif @nombres.respond_to?("each")
# @nombres es una lista de algn 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, slo imprime tres puntos. No hay
razn para saludar a nadie, cierto?
Iterando
9

Si el objeto @nombres responde al mtodo 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 automticamente se convierta en un string y usamos el saludo por defecto.
Veamos ese iterador en ms detalle:
@nombres.each do |nombre|
puts "Hola #{nombre}"
end
El mtodo each acepta un bloque de cdigo y lo ejecuta por cada elemento de la lista, y el cdigo
entre do y end es el bloque en s mismo. Un bloque es como una funcin annima o lambda. La variable
entre los pipes (|) es el parmetro para este bloque.
Lo que sucede es que por cada elemento en la lista, nombre va tomando su valor y se ejecuta la
expresin puts "Hola #{nombre}" con ese nombre.
Muchos otros lenguajes de programacin manejan la iteracin de una lista usando la clsica 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 cmo recorrerla. La costumbre Ruby (The Ruby Way) es
mucho ms elegante, todos los detalles de infraestructura se ocultan en el mtodo each, todo lo que
necesitas hacer es decirle qu hacer con cada elemento. Internamente, el mtodo each llamar yield
"Alberto", despus yield "Beatriz", despus yield "Carlos", y as sucesivamente.
Los bloques, una de las funcionalidades ms potentes de Ruby
El poder real de los bloques se disfruta al trabajar con cosas ms complicadas que las listas. Ms all de
manejar los detalles de infraestructura dentro del mtodo, tambin puedes manejar la inicializacin, la
finalizacin, y los errorestodos ocultos y simplificados frente a las preocupaciones del desarrollador.
# Decirle adis 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 "Adis #{@nombres.join(", ")}. Vuelvan pronto."
else
puts "Adis #{@nombres}. Vuelve pronto."
10

end
end
El mtodo decir_adios no usa each, en vez de eso se fija si @nombresresponde al mtodo join, y si es
as, lo usa. Si no es as, simplemente imprime la variable como un string. Esta prctica de no preocuparse
sobre el tipo de objeto de una variable, y simplemente depender de los mtodos 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
mtodo join con la misma semntica que otras listas, todo funcionar como fue planeado.
Arrancando el Script
As que eso es la clase MegaAnfitrion, el resto del archivo slo llama a los mtodos de la clase. Hy un
ltimo truco para tener en cuenta, y es la linea:
if __FILE__ == $0
__FILE__ es la variable mgica 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 verificacin dice si este es
el archivo principal. Esto permite que un archivo sea utilizado como una biblioteca, y no ejecutar
cdigo en ese contexto. Pero si el archivo est siendo usado como un ejecutable, entonces ejecuta ese
cdigo.
Considrate iniciado
Eso es todo en este rpido paseo por Ruby. Hay mucho ms por explorar, las estructuras de control
diferentes que ofrece Ruby; el uso e los bloques y yield; mdulos como mixins; y ms. Espero que esta
pequea muestra de Ruby te despierte el inters por saber ms.
Si es as, por favor dirgete a nuestra area de Documentacin, donde encontrars vnculos a cursos y
manuales, todos disponibles gratuitamente en internet.
O si realmente te gustara sumergirte en un libro, busca en el listado de libros los ttulos disponibles para
venta en linea o en tu tienda favorita.