Está en la página 1de 10

Todo lo que siempre quisiste saber sobre Ruby y no te vamos a contar

William Viana <wviana@aditel.org>


Andreu Belmonte <andreu@aditel.org>

13 de noviembre
Contenidos

1 Introducción 4

2 puts "Ruby mola mazo!" 5


2.1 Invocando el intérprete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.3 Tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3.1 Números . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3.2 Cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3.3 Símbolos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3.4 Rangos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3.5 Expresiones regulares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.3.6 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3.7 Hashes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

3 Condicionando y repitiendo 14
3.1 Expresiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.1.1 if y unless . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.1.2 case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.2 Bucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

1
William Viana y Andreu Belmonte 2

3.2.1 while y until . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17


3.2.2 for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

4 New kids on the block 19


4.1 Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.1.1 Cómo hacer bien un finger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.2 Bloques e iteradores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.2.1 ¿Qué echan en el cine? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

5 Un lenguaje con clase 27


5.1 Clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
5.1.1 Acceso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5.1.2 Herencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
5.2 Módulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.3 Mixins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

6 Si no lo apunto se me olvida 34
6.1 La clase File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
6.2 Bienvenido al mundo falible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
6.3 ¿Qué voy a ver en el cine? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

7 Qt4-Ruby 37
7.1 Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
7.2 Estructura de un interfaz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
7.2.1 Signal’n’Slots: Connecting Peoples’ objects . . . . . . . . . . . . . . . . . . . . . . . . . . 39
William Viana y Andreu Belmonte 3

7.3 Diseño del interfaz: Designer-qt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40


7.4 Implementación de la funcionalidad del interfaz . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
7.5 Aplicación principal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

8 Dice la leyenda que se empieza por documentar y se acaba por implementar 46


8.1 Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
8.2 SimpleMarkup o yo solo sé HTML, ¿como se juega a esto? . . . . . . . . . . . . . . . . . . . . . . 47
8.3 ¿y ahora?. . . ejecución sobre nuestro código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

9 Material relacionado 51

10 Agradecimientos 52

11 Sobre este documento 53


1 Introducción

Ruby es un lenguaje de programación orientado a objetos puro. Se basa sobretodo en la sintaxis de Perl y en
la orientación a objetos de SmallTalk. Fue creado por el japonés Yukihiro ’Matz’ Matsumoto quien lo liberó al
público en 1995. Es distribuido bajo dos licencias: una propia y la GPL.
Ruby es un lenguaje interpretado y no es de los más rápidos. Matz lo que quería hacer era un lenguaje divertido
de programar, en el que el programador pudiera ser muy productivo en poco tiempo. A mí al menos divertido
me resulta :)
Sobre las versiones, la última versión estable es la 1.8.4 y la que está en desarrollo es la rama 1.9 que será la
futura versión 2.0
En este manual/tutorial aprenderemos lo básico del lenguaje para empezar a programar scripts sencillos. Apren-
der a hablarlo fluidamente será cosa tuya. Talvez para la compresión de este manual haga falta ciertas nociones
sobre programación orientada a objetos, así que si no las tienes haz los deberes y al menos busca información en
la wikipedia sobre el tema.

4
2 puts "Ruby mola mazo!"

2.1 Invocando el intérprete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6


2.2 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.3 Tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3.1 Números . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3.2 Cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3.3 Símbolos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3.4 Rangos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3.5 Expresiones regulares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.3.6 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3.7 Hashes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

5
William Viana y Andreu Belmonte 6

Todo lenguaje de programación se empieza a aprender con un programa que imprime en pantalla "Hola mundo!".
Nosotros seremos un poco más originales, pero no demasiado, y aprenderemos a imprimir en pantalla "Ruby mola
mazo!". De hecho eso es lo que justamente hace el título del capítulo.
Sigamos con algo un poco más serio.

2.1 Invocando el intérprete


Hay varias maneras de invocar el intérprete Los ficheros de código fuente de Ruby llevan la extensión .rb y el intérprete se llama ruby. Nuestro primer
pasándole argumentos en la línea de coman- programa tendrá este aspecto:
dos. Por ejemplo con el parámetro -e pode-
mos ejecutar código desde la misma línea de hola_mundo.rb
comandos: #! / u s r / b i n / env r u b y
ruby -e ’puts "Hola mundo!"’ p u t s " Ruby mola mazo ! " # e s t o e s un c o m e n t a r i o .
Con -c simplemente se comprueba la sintaxis
del código y con -w se activan los warnings. La primera línea indica, en un sistema Unix, con qué intérprete se ha de interpretar ese fichero. Para ejecutar
Para ver una lista con todas las opciones nuestro programa desde la línea de comandos podemos hacerlo así:
disponibles:
ruby hola_mundo.rb
man ruby
o si el fichero tiene permisos de ejecución simplemente:
./hola_mundo.rb
También podemos usar el intérprete interactivo de Ruby que se llama irb.
i r b > p u t s " Ruby mola mazo ! "
Ruby mola mazo !
=> n i l

2.2 Variables
En realidad lo que se almacenan en las vari- Las variables en Ruby no necesitan declararse y no tienen tipo, puedes almacenar en ellas lo que sea. Las
ables son referencias, no un valor. Esto puede constantes deben empezar con una letra mayúscula y si intentas cambiar el valor de una constante durante la
causar algún dolor de cabeza si no se tiene en ejecución Ruby te lanzará un warning. Las variables globales empiezan con un símbolo del dólar y las constantes
cuenta. globales con un dólar seguido de una letra mayúscula. Algunos ejemplos de nombres de variables:
foo bar Pi $IVA $Precio
William Viana y Andreu Belmonte 7

Resta saber qué tipo de datos se pueden almacenar en una variable, sigue leyendo.

2.3 Tipos
2.3.1 Números

Al principio he dicho que Ruby era un lenguaje orientado a objetos y ahora lo empezaremos a notar. Todos los
tipos base en Ruby son objetos. Los números enteros pertenecen a la clase Fixnum si están comprendidos entre
un rango 2−30 y 230 y Bignum para cualquier número entero fuera de ese rango.
También se pueden utilizar diferentes bases de representación (binaria, octal, hexadecimal,...) Los números reales
pertenecen a la clase Float y también se pueden representar en notación científica.
i r b > 0xFF #h e x a d e c i m a l
=> 255
El método methods devuelve una lista con to- i r b > 0 b010 #b i n a r i o
dos los métodos disponibles del objeto. Otra => 2
manera de averiguar qué metodos tiene un i r b > 020 #o c t a l
objeto es ejecutar el interprete interactivo de => 16
irb> 0.000125
ruby con la opción de autocompletado
=> 0 . 0 0 0 1 2 5
irb –readline -r i r b > 1 . 2 5 e−5
irb/completion => 1 . 2 5 e −05
escribir un valor o variable seguido de un punto i r b > 1 . 2 5 e−3
y darle al tabulador. Esto es válido no sólo => 0 . 0 0 1 2 5
para objetos de la clase Fixnum sino para irb> 0.00125
cualquier objeto y es una buena manera de => 0 . 0 0 1 2 5
explorar los métodos disponibles de una clase.
Como todo objeto de una clase los números tienen sus propios métodos.
irb> 42. c l a s s
=> Fixnum
i r b > −3.abs #v a l o r a b s o l u t o
=> 3
i r b > 4 . succ #s u c e s o r de 4
=> 5
i r b > 3 . 1 4 1 5 . to_i
=> 3
William Viana y Andreu Belmonte 8

i r b > 5 . times { p r i n t "JA" }


JAJAJAJAJA=> 5

La última línea quizás sea la única que merece una explicación. Traducido del inglés y leído en voz alta pone
esto:
5 veces imprime JA
Muy legible, ¿verdad? Casi se parece al lenguaje natural. Vayamos por partes: times es un iterador y lo que va
entre llaves es el bloque que se le pasa al iterador. Don’t panic! Veremos más sobre iteradores y bloques más
adelante.

2.3.2 Cadenas

Una cadena es cualquier símbolo rodeado entre comillas dobles o simples.Las cadenas con comillas dobles permiten
El primer carácter de una cadena es el de secuencias de escape, como “\n” o “\t”, y la potente expresión de evaluación #{ }. Los operadores de suma
índice 0. Además se puede acceder a los car- y multiplicación permiten concatenar y repetir cadenas. Ruby tiene además el operador de adición por el
acteres de una cadena en orden inverso uti- final << para concatenar cadenas.
lizando números negativos: el último carácter Podemos filetear una cadena con el operador de corte [x..y] donde x e y son números enteros. El operador
es el -1, el penúltimo el -2,... devuelve una subcadena formada por los caracteres entre las posiciones x e y de la cadena. Combinado con el
operador de asignación el operador de corte sirve para sustituir subcadenas de una cadena. Con unos ejemplos
quedará todo más claro:
i r b > p u t s " \tRuby mola #{’mucho ’ ∗ 3 } mas que Python "
Ruby mola mucho mucho mucho mas que Python
=> n i l
i r b > cad1 = " chunky "
=> " chunky "
i r b > cad1 += " bacon "
=> " chunky bacon "
i r b > cad1 << " " + cad1
=> " chunky bacon chunky bacon "
i r b > cad1 [ 7 . . 1 1 ]
=> " bacon "
i r b > cad1 [ 0 . . 1 4 ] = " k e v i n "
=> " k e v i n "
i r b > cad1
William Viana y Andreu Belmonte 9

=>" k e v i n bacon "

String, al igual que las otras clases de tipos Las cadenas pertenecen a la clase String y, cómo Ruby mola mucho, tienen un montón de métodos molones que
base de Ruby, tiene muchos métodos y no va- nos facilitan la vida. Y para muestra un botón:
mos a verlos todos aquí. Sus nombres son
bastante autoexplicativos, recomiendo que los hola_fulanito.rb
pruebes en el intérprete interactivo. Conocer- 1 p r i n t " I n t r o d u c e nombre y a p e l l i d o s : "
los hará que amplíes vocabulario y alcances 2 nombre_completo = g e t s
cierta fluidez en el lenguaje. 3 nombre_completo . s t r i p !
4 p r i n t " Hola "
5 nombre_completo . each ( " " ) { | p a l a b r a | p r i n t p a l a b r a . c a p i t a l i z e , " " }

Para empezar vemos dos métodos nuevos: print y gets. print es igual que puts pero no añade un salto de línea
al final y gets lee una cadena del teclado. El método strip! remueve el \n del final de la cadena si lo hay. Los
métodos que terminan con un símbolo ! indican que el objeto va a ser modificado. Por último, vuelve a aparecer
un iterador y un bloque. Iteradores y bloques se usan mucho en Ruby y siempre los veremos cogidos de la mano.
El iterador each sobre cadenas va tomando los valores de sus elementos. Por defecto considera que los elementos
en una cadena están separados por un \n, por eso le especificamos que tome como delimitador un espacio en
blanco para que considere cada palabra como un elemento. Lo que va dentro de las barras verticales es la variable
que interactúa con el bloque; each le va pasando al bloque los valores que va tomando a través de la variable
palabra

2.3.3 Símbolos

Los símbolos empiezan por el símbolo : y pueden contener letras, dígitos o barras bajas. Para Ruby los símbolos
son más fáciles de procesar que las cadenas. Generalmente los usarás cuando necesites una cadena pero no
necesites imprimirlo por pantalla, por ejemplo para pasarle un mensaje a un objeto.
:soy_un_simbolo :rojo :mil :on :off

2.3.4 Rangos

Los rangos en Ruby también son un tipo. Se representan por dos valores entre paréntesis separados por dos o
tres puntos.
(1..5) representa los números del 1 al 5