Você está na página 1de 37

Introduccin

Qu es Ruby?
Ruby es un lenguaje multiplataforma, interpretado y orientado a objetos. Ruby fue diseado por YukihiroMatsumoto ('Matz') en 1993, con el Principio de la Menor Sorpresa: Matz dice "quera minimizar mi frustracin mientras programo, y eso conllevaba minimizar mi esfuerzo. Este es el principal objetivo de Ruby. Quiero divertirme mientras programo. Despus de lanzar Ruby y probarlo mucha gente, ellos me dijeron que sentan lo mismo que yo. Ellos fueron los que acuaron el trmino de "Principio de Menor Sorpresa". En el ao 2004 hubo un boom en el inters por Ruby, debido a Ruby onRails: el entorno para desarrollo web de David HeinemeierHansson.

Cmo puede ayudarte?


En el libro de David Black "Ruby forRails", l menciona que un buen conocimiento en Ruby puede ayudarte, como desarrollador de Rails, en cuatro formas: 1. a conocer mejor el cdigo de tu aplicacin (incluso el cdigo que Rails escribe automticamente). 2. a ser ms productivo con Rails, incluso si dominas todas sus tcnicas. 3. a familiarizarte mejor con el cdigo de Rails, lo que te permitir participar en discusiones sobre Rails y quizs poder ayudar detectando bugs o aportando patches. 4. a utilizar una poderosa herramienta para tareas de administriacin y organizacin conectadas con tu aplicacin.

Algunas caractersticas
y y y Libre de formato: una cosa se puede hacer de distintas maneras. Escoge la que mejor se adapte a tu forma de trabajo. Sensible a las maysculas: dos palabras, aunque se diferencien solamente en una letra, por estar en mayscula o minscula, son dos cosas distintas. Por ejemplo, 'Dir' no es lo mismo que 'dir'. Comentarios: cualquier lnea precedida por '#' es ignorada por el intrprete. Adems, cualquier cosa que escribamos entre las lneas '=begin' y '=end, tambin ser ignorada.

#Comentario de una sola lnea =begin Esto es un comentario de varias lneas =end =begin Este comentario multilnea da un error. =end MUY IMPORTANTE: este ltimo tipo de comentarios, no puede tener espacios a su izquierda, por que dara un error. Por lo tanto, si se quiere usar, siempre van pegados al margen izquierdo de la pantalla.

Delimitadores de instruccin: varias instrucciones en una misma lnea pueden ser separadas por un ';', pero no son necesarios al final de una lnea: este final de lnea (o retorno de carro) se trata como un ';'. Si un final de lnea acaba con un '\', entonces el retorno de carro es ignorado, lo que permite tener una instruccin divida en varias lneas.

#Varias instrucciones en una misma lnea a =1; b=2; c=3 #es equivalente a: a = 1 b = 2 c = 3 #Una instruccin en varias lneas a = 'enjuto mojamuto' #es equivalente a: a = "enjuto \ mojamuto" y Palabras clave: tambin conocidas como palabras reservadas, son palabras en Ruby que no pueden ser usadas para otros propsitos, por ejemplo, como almacenar valores. Adems, puedes estar acostumbrado a pensar que un valor 'falso' puede estar representado por 0, una cadena vaca o varias otras cosas. 'false' y 'nil': En Ruby, todo esto es vlido; de hecho, todo es cierto excepto las palabras reservadas 'false' y 'nil'.

El Primer Programa
Usemos el editor SciTE: Start/Programas/Ruby/SciTe. Se abre el editor. Para cambiar los parmetros de arranque, Options/Opens Global y all modificar: y y tabsize=2, indent.size=2 (tamao del tabulador, y el identado) position.width=-1, position.height=-1 (arrancar maximizado)

una vez cambiados los valores, pulsar Ctrl+S y Ctrl+S. Para modificar estos dos valores, otra forma es: y y Ctrl+Shift+I - abre un dilogo donde modificar los valores anteriores. Tienen que ser =2. F11 - para maximizar minimizar la ventana.

Lo ltimo que falta antes escribir los programas, es un abrir una ventana de terminal para ver los resultados de los programas. Para ello hay que pulsar F8. Una vez ajustado el SciTE, lo siguiente es crear un directorio donde ir guardando los programas que vayamos creando.

'Hola'
En la ventana izquierda de SciTE (tiene que haber 2 ventanas despus de pulsar F8), escribir: #p001hola.rb puts'Hola' Ahora hay que guardar y ejecutar el programa. Las normas dicen que el nombre del fichero o directorio, es el nombre en minsculas de la clase/mdulo (ms adelante se hablar de clases y mdulos). Por ejemplo, la clase Foo est en el fichero foo.rb. Para guardar el fichero: File\Save AsSlvalo como p001hola.rb . Todos los ficheros de cdigo Ruby tienen la terminacin "rb". Ahora ejecuta el programa: pulsa F5. En la ventana de output aparecer la palabra "Hola". En Ruby, la ejecucin de las instrucciones del programa, va de la primera a la ltima: #p001hola.rb No hace nada. Todas las lneas precedidas por '#' son comentarios. Y los comentarios se ignoran al ejecutarse el programa. puts'Hello' puts significa putstring = poner string. String es una cadena de texto. Esta instruccin saca por el output cualquier cosa que pongamos a su derecha.

Normas de cdigo
Los parntesis son opcionales cuando usamos un mtodo, en este caso puts. Las siguientes instrucciones son correctas: foobar foobar() foobar(a, b, c) foobar a, b, c

En Ruby, todo desde un nmero entero a una cadena de texto, es un objeto. Hablaremos ms de esto. Y cada objeto tiene sus propios mtodos (o instrucciones o funciones) que pueden ser usados para hacer cosas muy tiles. Para usar un mtodo, necesitas poner un '.' despus del nombre del objeto, y luego poner el nombre del mtodo. Algunos mtodos como puts y gets no necesitan estar asociados a un objeto, y por tanto pueden ser usados desde cualquier parte. Cuando se ejecuta una aplicacin en Ruby, siempre se crea un objeto llamado main de la clase Object: este objeto es el que tiene dentro los mtodos Kernel. De todo esto se hablar ms adelante. Todo esto se puede verificar por el siguiente programa (no te preocupes si no entiendes el programa, ms adelante se explicar): puts'Soy una clases = ' + self.class.to_s puts'Soy un objeto = ' + self.to_s print'Los mtodos del objeto son = ' putsself.private_methods.sort

Observar
y y y y Programadores de C y Java - no se necesita escribir un mtodo main. Los strings son secuencias de caracteres entre simple o dobles comillas. Las comillas simples son ms eficientes que las dobles. Se explicar ms adelante. Ruby es un lenguaje interpretado, entonces no hace falta recompilar para ejecutar un programa. Las normas de cdigo en Ruby, establecen que el nombre del fichero/directorio tiene que ser el nombre de la clase/mdulo en minsculas, aadiendo la extensin .rb

Nmeros en Ruby
Juguemos con los nmeros
En Ruby, los nmeros sin la coma decimal son llamados enteros, y los enteros con decimales son llamados coma-flotantes, o ms sencillamente, flotantes. puts1 + 2 puts10 - 11 puts2 * 3 #Divisn: cuando divides dos enteros, obtienes un entero: puts3 / 2 #si quieres obtener el resultado de decimal, #al menos uno de los dos tiene que ser decimal puts 3.0 /2 puts3 / 2.0 puts 1.5 /2.6 Los nmeros en Ruby son objetos de la clase Fixnum o Bignum: estas clases representan nmeros enteros de distintos tamaos. Ambas clases descienden de la clase Integer (en ingls, integer=entero). Los nmeros coma-flotantes son objetos de la clase Float (en ingls, float=flotante). Una diagrama de la jerarqua de las clases (Donald Craig):

Veamos el ejemplo que Peter Cooper nos propone, sacado de su libro "Beginning Ruby" (no importa que todava no seas capaz de entender todo el cdigo): =begin Problema del tablero de ajedrez: si en la primera casilla ponemos un grano, y duplicamos la cantidad de granos en la siguiente, y as hasta rellenar el tablero, cuntos granos tendremos? =end granos = 1 64.timesdo |escaque| puts"En el escaque #{escaque+1} hay #{granos}" granos *= 2 end Al final tenemos 2.2.2...2.2=264 granos en la ltima casillatrillones de granos! Esto demuestra que Ruby es capaz de manejar nmeros extremadamente grandes, y a diferencia de otros lenguajes de programacin, no hay lmites en esos nmeros. Ruby hace esto gracias a las distintas clases antes mencionadas: y y Fixnum - maneja los nmeros pequeos Bignum - maneja los nmeros grandes (en ingls, big=grande).

Ruby escoger cul usar, y t nicamente tendrs que preocuparte por lo que quieras hacer con ellos.

Operadores y precedencia
Echmosle un ojo a los operadores de Ruby (HalfFulton - The Ruby Way). Estn ordenados de mayor a menor rango de precendencia; dicho de otra forma, los de la parte superior de la tabla, son los primeros en ejecutarse.

: [] ** +-!~ */% + &

Alcance (scope) ndices Exponentes Unarios: pos/neg, no, Multiplicacin, Divisin, Suma, Resta, Desplazadores binarios, 'y' binario

|, ^ >>= <<= == === <=> != =~ !~ && || .. = (+=, -=,...) ?: not and, or


Destacar que:

'or' y 'xor' binarios Comparadores Igualadad, inegualdad, 'y' booleano 'o' booleano Operadores de rango Asignadores Decisin ternaria 'no' booleano 'y', 'o' booleano

1. Los parntesis funcionan de la misma forma que en las matemticas: cualquier cosa dentro de ellos es calculado en primer lugar. O dicho ms tcnicamente: tienen ms precedencia. 2. Los operadores incremento y decremento (++ y ) no estn disponibles en Ruby, ni en su forma "pre" ni en su forma "post".

El operador mdulo
El operador mdulo, que nos da el resto de una divisin, se comporta como sigue: puts puts puts puts (5 % 3) (-5 % 3) (5 % -3) (-5 % -3) # # # # imprime 2 imprime 1 imprime -1 imprime -2

Ejercicio
Escribir un programa que diga cuantos minutos hay en un ao de 365 das.

Strings y diversin
Los strings (o cadenas de texto) son secuencias de caracteres entre comillas simples o comillas dobles. '' (dos comillas simples) no tienen nada: podemos llamarlo string vaco. puts"Hola mundo" # Se puede usar " o ' para los strings, pero ' es ms eficiente. puts'Hola mundo' # Juntando cadenas puts'Me gusta' + ' Ruby' # Secuencia de escape puts'Ruby\'s party' # Repeticin de strings puts'Hola' * 3 # Definiendo una constante # Ms adelante se hablar de constantes PI = 3.1416 puts PI En Ruby las cadenas son mutables: se pueden modificar. Ruby almacena las cadenas como secuencias de bytes.

Strings con acento grave `


Hay unos strings especiales que se diferencian por usar como delimitador el acento grave `: puts `dir` El string entre los acentos, es enviado al sistema operativo como un comando a ser ejecutado. El resultado devuelto por el sistema, es recogido por Ruby. En este caso, al estar puts, obtendremos en pantalla el resultado de `dir`.

Interpolacin
Con la interpolacin nos referimos al proceso de insertar el resultado de una expresin dentro de un string. La forma de hacerlo es mediante #{ expresin }. Ejemplo: puts"100 * 5 = #{100 * 5}" La seccin #{100*5} se ejecuta y pone el resultado en esa posicin. Es decir, 500.

Comillas simples (') vs comillas dobles (")


La diferencia entre ambas formas, es el tiempo que se toma Ruby en cada una: mientras que con las simples comillas, Ruby hace muy poco; en las dobles comillas, Ruby tiene que hacer ms trabajo: 1. busca posibles substituciones: las secuencias de escape (las que empiecen por un \) son sustituidas por su valor binario. 2. busca posibles interpolaciones: en las secuencias con #{expresin}, se calcula la expresin, y se sustituye el bloque entero por su resultado. defdi_adios(nombre) resultado = "Buenas noches, #{nombre}"

return resultado end putsdi_adios('Pepe') =begin Como los mtodos devuelven el valor de la ltima lnea, no hace falta elreturn. =end def di_adios2(nombre) resultado = 'Buenas noches, ' + nombre end puts di_adios2('Pepe') =begin Ahora, en vez de usar ", usamos ', utilizando la concatenacin de strings para obtener el mismo resultado. =end

String#length
String#length devuelve el nmero de bytes de una cadena. string = "Esto es una cadena" string.length# => 18 string.length devuelve 18. Cuenta todas las letras, incluidos los espacios en blanco.

Variables
Para almacenar un nmero o un string en la memoria del ordenador, con el fin de usarlos en clculos posteriores, necesitas dar un nombre a ese nmero o string. En programacin este proceso es conocido como asignacin. #Ejemplos de asignaciones s = 'HelloWorld!' x = 10 Las variables locales en ruby son palabras que: 1. deben empezar con un letra minscula o un guin bajo (_) 2. deben estar formadas por letras, nmeros y/o guiones bajos. Cuando Ruby enucuentra una palabra, la interpreta como: una variable local, un mtodo o una palabra clave. Las palabras claves no pueden ser usados como variables. Por ejemplo def es una palabra clave: slo se puede usar para definir un mtodo. if tambin es una palabra clave: gran parte del cdigo consta de instrucciones condicionales que empiezan con if, por eso sera muy confuso si pudiese usarse como variable. Los mtodos pueden ser palabras, como start_here, puts o print. Cuando Ruby encuentra una palabra decide qu es de la siguiente forma: 1. si hay un signo de igualdad (=) a la derecha de la palabra, es una variable local a la que se le asigna un valor. 2. si la palabra es una palabra clave, entonces es una palabra clave. Ruby tiene una lista interna para poder reconocerlas. 3. Si no se cumple ninguno de los anteriores casos, Ruby asume que es un mtodo. # Definicin de una constante PI = 3.1416 puts PI # Definicin de una variable local myString = 'Yo amo mi ciudad, Vigo' putsmyString =begin Conversiones to_i - convierte a nmero entero to_f - convierte a nmero decimal to_s - convierte a string =end var1 = 5 var2 = '2'#fijarse que es un texto puts var1 + var2.to_i =begin << marca el comienzo de un string y es seguido de ' o ''. Aqu aadimos elstring junto con el retorno de carro (\n). =end a = 'molo ' a<<'mucho. Molo mazo...'

puts a =begin ' o " son los delimitadores de un string. En este caso, podemos sustituirlos por END_STR. END_STR es una constante delimitador de strings. =end a = <<END_STR Thisisthestring And a second line END_STR puts a En el ejemplo: var2.to_i el punto significa que el mtodo to_i es enviado a la variable var2, que este caso es un string: transformamos el string en un nmero para poder sumarlos. Cuando hablemos de objetos, veremos que se puede decir que la var2 es el receptor de to_i. Por lo tanto, cuando aparezca un punto en una posicin inexplicable, habr que interpretarlo como un mtodo (la parte derecha) que es enviado a un objeto (la parte izquierda).

Interpretacin Dinmica
Por interpretacin dinmica, se entiende que no hace falta especificar qu tipo de variable se va a manejar: si parece un nmero, problablemente sea un nmero; si parece una cadena, problablemente lo sea. El mtodo class devuelve el tipo de clase de un objeto: s = 'hello' s.class# String Otro ejemplo: # x x x Ruby es dinmico = 7#nmero entero = "house"#string = 7.5#nmero real

Alcance
El alcance es una propiedad de las variables: se refiere a su visibilidad. Los distintos tipos de variables, tienen distintas reglas de alcance. Hablemos de dos tipos de variables: las globales y las locales.

Alcance global y variables globales


Empezarmos con el alcance que menos se usa, pero no por ello menos importante: un alcance global significa que alcanza a todo el programa. Desde cualquier parte del programa, puede usarse la variable. Las variables globales son las que tienen alcance global. Las variables globales se distinguen porque estn precedidas del signo dlar ($). Pueden ser vistas desde cualquier parte del programa, y por tanto pueden ser usadas en cualquier parte: nunca quedan fuera de alcance. Sin embargo, las variables globales son usadas muy poco por los programadores experimentados.

Variables globales por defecto


El intrprete Ruby tiene por defecto un gran nmero de variables globales inicializadas desde el principio. Son variables que almacenan informacin til que puede ser usada en cualquier momento y parte del programa. Por ejemplo, la variable global $0 contiene el nombre del fichero que Ruby est ejecutando. La variable global $: contiene los directorios en los que Ruby busca cuando se carga un fichero que no existe en el directorio de trabajo. $$ contiene el id (identidad) del proceso que Ruby est ejecutando. Y hay muchas ms.

Alcance local
Nota: no te preocupes si no entiendes esto ahora. Se puede intuir mirando el cdigo dnde empieza y acaba el alcance de las variables locales, basndonos en: y y y El nivel ms alto (fuera de todos los bloques de definicin) tienen su propio alcance. Cada bloque de definicin de una clase o mdulo tienen su propio alcance, incluso los bloques anidados. Toda definicin de un mtodo (def) tiene su propio alcance.

Introduciendo datos (gets)


Lecciones atrs vimos el mtodo puts que saca datos por la pantalla. Cmo podemos introducir nuestros propios datos? Para esto gets (get=coger, s=string) y chomp son de ayuda. Veamos el siguiente ejemplo: # gets y chomp puts"En qu ciudad te gustara vivir?" STDOUT.flush ciudad = gets.chomp puts"La ciudad es " + ciudad El ejemplo superior, al ser ejecutado en SciTe, clickea en la pantalla de output y pon el nombre de tu ciudad favorita. STDOUT es una constante global que almacena las salidas del programa. flush vaca cualquier dato almacenado, y por lo tanto, limpiar cualquier resultado anterior. chomp es un mtodo para strings y gets almacena strings que provienen del teclado. El problema es que gets almacena lo escrito y el carter '\n' (retorno de carro); chomp lo que hace es remover esa '\n'. RAILS: los datos vienen de muchos sitios. En la tpica aplicacin de Rails, vienen de una base de datos. Como un desarrollador de Rails, puedes usar con frecuencia algunos de estos mtodos, porque Rails recoge los datos que los usuarios escriben en los formularios Web.

Ejercicio
Escribe un programa que pregunte por la temperatura en grados Fahrenheit. El programa usar este dato, y hallar el equivalente en grados Celsius. El resultado final lo mostrar en pantalla con dos decimales. Nota: para formatear un resultado a dos decimales, hay dos opciones: y usar el mtodo format. Por ejemplo:

x = 45.5678 putsformat("%.2f", x) y otra forma es la funcin round:

puts (x*100).round/100.0

Normas en las palabras


Un nombre es una letra mayscula, una letra minscula o un guin bajo, seguido por cualquier combinacin de maysculas, minsculas, nmeros o guiones bajos. Los nombres en Ruby se usan para referirse a constantes, variables, mtodos, clases y mdulos. La primera letra de un nombre ayuda a Ruby a distinguirlos. Algunos nombres, son palabras reservadas y no pueden usarse como variable, mtodo, clase o mdulo. El conjunto de las minsculas abarca de la 'a' a la 'z' incluyendo el guin bajo '_'. El conjunto de las maysculas abarca de la 'A' a la 'Z' y los nmeros (del '0' al '9').

Variables
Las variables contienen cualquier tipo de dato. El propio nombre de la variable, muestra su alcance (local, global,): y Una variable local consiste en una letra minscula o guin bajo seguido de cualquier mayscula o minscula. P.ej.: sunil, _z, rock_and_roll Una variable de un objeto (ms adelante se hablar de clases y objetos) empieza con la arroba, seguido de cualquier mayscula o minscula. P.ej.: @sign, @_, @Counter Una variable de clase empieza con dos arrobas seguido por cualquier mayscula o minscula. P.ej: @@signo, @@_, @@Counter Una variable global empieza por el signo dlar, seguido por cualquier carcter(no slo maysculas o minsculas). P.ej: $counter, $COUNTER, $-x.

Constantes
Una constante empieza por una letra mayscula, seguido por cualquier mayscula o minscula. Los nombres de clases y de mdulos son constantes, y siguen unas normas. Ejemplos: module MyMath, PI=3.1416, class Perro. Los nombres de mtodos deben empezar por una minscula (letra o guin bajo). La ? y la ! son los nicos caracteres ajenos al grupos de las maysculas y minsculas, que se permiten como sufijos de los mtodos. Ms adelante se explicar su uso. Por norma, se usa el guin bajo para separar palabras compuestas en los nombres de mtodos y de variables. Para los nombres de clases, mdulos y constantes, la norma dice de usar letras maysculas en vez de guiones bajos, para distinguirlas. Ejemplos: y y variables y mtodos: real_madrid, futbol_club_barcelona clases, mdulos y constantes: RealMadrid, FutbolClubBarcelona

Hay que notar que una variable puede referirse a distintos valores a lo largo del tiempo. Una constante en Ruby puede ser una referencia a un objeto. Las constantes son creadas en el momento de su primera asignacin, normalmente en la definicin de una clase o un mdulo; no deben estar definidas en los mtodos. Se puede variar el valor de una constante, pero esto genera un valor de aviso.

Normas en las palabras


Un nombre es una letra mayscula, una letra minscula o un guin bajo, seguido por cualquier combinacin de maysculas, minsculas, nmeros o guiones bajos. Los nombres en Ruby se usan para referirse a constantes, variables, mtodos, clases y mdulos. La primera letra de un nombre ayuda a Ruby a distinguirlos. Algunos nombres, son palabras reservadas y no pueden usarse como variable, mtodo, clase o mdulo. El conjunto de las minsculas abarca de la 'a' a la 'z' incluyendo el guin bajo '_'. El conjunto de las maysculas abarca de la 'A' a la 'Z' y los nmeros (del '0' al '9').

Variables
Las variables contienen cualquier tipo de dato. El propio nombre de la variable, muestra su alcance (local, global,): y Una variable local consiste en una letra minscula o guin bajo seguido de cualquier mayscula o minscula. P.ej.: sunil, _z, rock_and_roll Una variable de un objeto (ms adelante se hablar de clases y objetos) empieza con la arroba, seguido de cualquier mayscula o minscula. P.ej.: @sign, @_, @Counter Una variable de clase empieza con dos arrobas seguido por cualquier mayscula o minscula. P.ej: @@signo, @@_, @@Counter Una variable global empieza por el signo dlar, seguido por cualquier carcter(no slo maysculas o minsculas). P.ej: $counter, $COUNTER, $-x.

Constantes
Una constante empieza por una letra mayscula, seguido por cualquier mayscula o minscula. Los nombres de clases y de mdulos son constantes, y siguen unas normas. Ejemplos: module MyMath, PI=3.1416, class Perro. Los nombres de mtodos deben empezar por una minscula (letra o guin bajo). La ? y la ! son los nicos caracteres ajenos al grupos de las maysculas y minsculas, que se permiten como sufijos de los mtodos. Ms adelante se explicar su uso. Por norma, se usa el guin bajo para separar palabras compuestas en los nombres de mtodos y de variables. Para los nombres de clases, mdulos y constantes, la norma dice de usar letras maysculas en vez de guiones bajos, para distinguirlas. Ejemplos: y y variables y mtodos: real_madrid, futbol_club_barcelona clases, mdulos y constantes: RealMadrid, FutbolClubBarcelona

Hay que notar que una variable puede referirse a distintos valores a lo largo del tiempo. Una constante en Ruby puede ser una referencia a un objeto. Las constantes son creadas en el momento de su primera asignacin, normalmente en la definicin de una clase o un mdulo; no deben estar definidas en los mtodos. Se puede variar el valor de una constante, pero esto genera un valor de aviso.

Los mtodos
En Ruby, todo lo que se manipula es un objeto, y el resultado de esas operaciones tambin son objetos. La nica forma que tenemos de manipular los objetos, son los mtodos: 5.times { puts"Ratn!\n" } #se hablar ms tarde de bloques "A los elefantes le gustan los cacahuetes".length Si los objetos (como los strings, nmeros,) son los nombres, entonces los mtodos son los verbos. Todo mtodo necesita un objeto. Es fcil decir qu objeto recibe el mtodo: el que est a la izquierda del punto. Algunas veces, puede que no sea obvio. Por ejemplo, cuando se usa putsy gets, dnde estn sus objetos? Nada ms iniciarse el intrprete, estamos dentro de un objeto: el objeto main. Por tanto, al usar puts y gets, estamos mandando el mensaje al objeto main. Cmo podemos saber dentro de qu objeto estamos? Usando la variable self. putsself Para ms detalles sobre self, mirar aqu.

Escribiendo mtodos
Un bloque de instrucciones que define un mtodo, empieza por la palabra def y acaba por la end. Los parmetros son la lista de variables que van entre parntesis. Aunque en Ruby, dichos parntesis son opcionales: puts, p y gets son muy usados, y por ello que el uso de parntesis sea opcional. En Rails, se llama a los mtodos sin parntesis. Un mtodo devuelve el valor de su ltima lnea. Por norma, es recomendable dejar una lnea en blanco entre las definiciones de mtodos: #metodos.rb # Definicin de un mtodo defhello puts'Hola' end #uso del mtodo hello # Mtodo con un argumento defhello1(nombre) puts'Hola ' + nombre return'correcto' end puts(hello1('Pedro')) # Mtodo con un argumento (sin parntesis, no funciona en versiones nuevas) defhello2nombre2 puts'Hola ' + nombre2 return'correcto' end puts(hello2'Juan') Esto es lo que obtenemos >rubymetodos.rb

Hola Hola Pedro correcto Hola Juan correcto metodos.rb:18 warning: parenthesizeargument(s) forfutureversion >Exitcode: 0

Los mtodos bang (!)


Los mtodos que acaban con una ! son mtodos que modifican al objeto. Por lo tanto, estos mtodos son considerados como peligrosos, y existen mtodos iguales, pero sin el!. Por su peligrosidad, el nombre "bang". Ejemplo: a = "En una lugar de la mancha" #mtodo sin bang: el objeto no se modifica b = a.upcase putsb putsa #mtodo con bang: el objeto se modifica c = a.upcase! putsc putsa Normalmente, por cada mtodo con !, existe el mismo mtodo sin !. Aquellos sin bang, nos dan el mismo resultado, pero sin modificar el objeto (en este caso el string). Las versiones con !, como se dijo, hacen la misma accin, pero en lugar de crear un nuevo objeto, transforman el objeto original. Ejemplos de esto son: upcase/upcase!, chomp/chomp!,En cada caso, si haces uso de la versin sin !, tienes un nuevo objeto. Si llamas el mtodo con !, haces los cambios en el mismo objeto al que mandaste el mensaje.

Alias
aliasnuevo_nombrenombre_original alias crea un nuevo nombre que se refiere a un mtodo existente. Cuando a un mtodo se le pone un alias, el nuevo nombre se refiere al mtodo original: si el mtodo se cambia, el nuevo nombre seguir invocando el original. defviejo_metodo "viejo metodo" end aliasnuevo_metodoviejo_metodo defviejo_metodo "viejo metodo mejorado" end putsviejo_metodo putsnuevo_metodo En el resultado, vemos como nuevo_metodo hace referencia al viejo_metodo sin modficar: viejometodomejorado viejometodo

NOTA: a da de hoy Ruby no se lleva muy bien con las tildes. Esto es por que no tiene soporte para strings Unicode. Se planea implementarlo en la versin 1.9 que saldr en Diciembre del 2007.

Mtodos perdidos
Cuando mandas un mensaje a un objeto, el objeto busca en su lista de mtodos, y ejecuta el primer mtodo con el mismo nombre del mensaje que encuentre. Si no encuetra dicho mtodo, lanza una errorNoMethodError. Una forma de solucionar esto, es mediante el mtodo method_missing: si definimos dicho mtodo dentro de una clase, se ejecuta este mtodo por defecto: classDummy defmethod_missing(m, *args) puts"No existe un metodo llamado #{m}" end end Dummy.new.cualquier_cosa obtenemos: No existe un metodo llamado cualquier_cosa Por lo tanto, method_missing es como una red de seguridad: te da una forma de manejar aquellos mtodos que de otra forma daran un error en tu programa

Los mtodos: argumentos


Valores por defecto
Ruby deja especificar los valores por defecto de los argumentos, que son usados si no se especifica un valor explcitamente. Se hace esto mediante el operador de asignacin (=): #argumentos.rb defmtd(arg1="Dibya", arg2="Shashank", arg3="Shashank") "#{arg1}, #{arg2}, #{arg3}." end putsmtd putsmtd("ruby") Hemos usado el operador interpolacin #{ }: se calcula la expresin entre parntesis, y el resultado se aade al string. Lo que obtenemos es: >rubyargumentos.rb Dibya, Shashank, Shashank. ruby, Shashank, Shashank. >Exitcode: 0

Nmero de argumentos variable


Ruby permite escribir funciones que acepten un nmero variable de argumentos. Por ejemplo: deffoo(*mi_string) mi_string.eachdo |palabras| putspalabras end end foo('hola', 'mundo') foo() El asterisco indica que el nmero de argumentos puede ser el que se quiera. En este ejemplo, el asterisco toma los argumentos y los asigna a un array (o vector de elementos) llamado mi_string. Haciendo uso de ese asterisco, incluso se pueden pasar cero argumentos; que es lo que pasa con foo(). No hay mximo nmero de argumentos que podamos pasar a un mtodo.

Argumentos opcionales
Si se quieren incluir argumentos opcionales, tienen que venir despus de los argumentos no opcionales: defarg_opc(a,b,*x)# bien defarg_opc(a,*x,b)# mal Los argumentos se interpretan de izquierda a derecha, por eso es importante que los argumentos no opcionales vayan en primer lugar. Si los pusisemos en ltimo lugar, no sabramos decir donde acaban los argumentos opcionales y donde empiezan los no opcionales. =begin

Ejemplo de como los argumentos s e interpretan de izquierda a derecha =end defmtd(a=99, b=a+1) [a,b] end putsmtd

Rangos
El principal uso y quizs el ms apropiado para los rangos, es expresar una secuencia: las secuencias tienen un punto inicial y un punto final, y una forma de producir los sucesivos valores entre ambos. En Ruby, esas secuencias son creadas usando los operandos .. y y .. genera una secuencia donde los puntos lmites estn incluidos.

(1..3).to_a #es la secuencia 1, 2, 3 y * genera una secuencia en la que no est incluida el lmite superior.

(1...5).to_a #equivale a 1, 2, 3, 4 En Ruby los rangos no son almacenados como una lista: los rangos se almacenan como un objeto Range, y contiene referencias a dos objetos Fixnum (su lmite superior e inferior). Se puede convertir un rango en un array( array = lista, conjunto ordenado de elementos), mediante el mtodo to_a. (1..10).to_a #obtenemos [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

mtodos
Los rangos en ruby tienen diversos mtodos: nums = -1...9 putsnums.include?(5) # true putsnums.min# -1 putsnums.max# 8 putsnums.reject {|i| i <5} # [5, 6, 7, 8, 9] Uno de los usos tiles de los rangos, es comprobar si un determinado valor est en el intervalo representado por el rango. Para eso usamos el operador === (1..10) === 5# true (1..10) === 15# false (1..10) === 3.14159# true ('a'..'j') === 'c'# true

Arrays
Un array (o lista) es un conjunto ordenado: cada posicin en la lista es una variable que podemos leer y/o escribir. # Arrays (o vectores) # array vaco vec1 = [] # Los ndices empiezan desde el cero (0,1,2,...) nombres = ['Satish', 'Talim', 'Ruby', 'Java'] puts nombres[0] puts nombres[1] puts nombres[2] puts nombres[3] # si el elemento no existe, se devuelve nil puts nombres[4] # pero podemos aadir a posteriori ms elementos nombres[3] = 'Python' nombres[4] = 'Rails' Un array puede ser un conjunto de elementos distintos: =begin unarray cuyos elementos apuntan a otros tres objetos: un decimal, un string y un array =end sabor = 'mango' vec4 = [80.5, sabor, [true, false]] puts vec4[2]

Usando %w
Algunas veces, crear arrays de palabras puede ser tedioso debido a tantas comillas y comas. Afortunadamente, Ruby tiene una forma ms cmoda para hacerlo: nombres1 = [ 'ann', 'richard', 'william', 'susan', 'pat' ] puts nombres1[0] # ann puts nombres1[3] # susan # esto es ms sencillo y ms rpido: nombres2 = %w{annrichardwilliamsusanpat } puts nombres2[0] # ann puts nombres2[3] # susan

El mtodo each
El mtodo each extrae cada elemento del array dentro de la variable que se le especifique (que ir entra dos barras | |), que se usar en bloque doend. ciudades = %w{ Pune Mumbai Bangalore } ciudades.eachdo |ciudad| puts'Me gusta ' + ciudad + '!' puts'A ti no?' end

#El mtodo {{**delete**}} borra un elemento ciudades.delete('Mumbai') ciudades.eachdo |ciudad| puts'Me gustaba '+ciudad+'!' puts'A ti ya no?' end Por lo tanto el mtodo each nos permite hacer una cosa (la que sea) con cada objeto del array. En el ejemplo, fuimos elemento por elemento del array sin usar los ndices. Hay que destacar: y y Los variable entre los "postes" se refiere a cada tem del array a medida que avanzamos en el loop. Se puede usar cualquier nombre, pero es mejor dotarlo de cierto significado. El doend identifica el bloque de cdigo que se ejecutar con cada elemento del array. Los bloques son usados intensivamente en Ruby, y se tratarn en profundidad ms adelante.

Otros mtodos
vec = [34, 12, 1, 38] putsvec.sort putsvec.length putsvec.first putsvec.last

Obteniendo arrays
Un mtodo puede devolver un array: defnum_cuadrado(num) cuadrado = num * num returnnum, cuadrado end =begin el mtodo nos devuelve unarray con el nmero y su cuadrado =end x=3 num_cuadrado(x) =begin si queremos almacenar el resultado hay que hacerlo por asignacin en paralelo =end num, cuadrado = num_cuadrado(x)

Ejercicios
1. Escribe un programa tal que, dado un array numrico, calcule la suma de sus elementos. Por ejemplo, array = [1, 2, 3, 4, 5] 1.2. Escribe un programa tal que, dado un array de nmeros, diga de cada uno si es par o impar. Por ejemplo, array = [12, 23, 456, 123, 4579]

Bloques
Un bloque es una porcin de cdigo encerrada entre parntesis {} o entre doend. Por lo tanto, un bloque es una forma de agrupar instrucciones, y solo puede aparecer despus de usar un mtodo: el bloque empieza en la misma lnea que usa el mtodo. El cdigo dentro del bloque no es ejectuado en el instante que el intrprete de Ruby lo encuentra: Ruby se recordar del bloque (variables locales, ) y despus entra en el mtodo, ejecutando el bloque cuando es preciso. Supongamos que existen dos mtodos llamados greet1 y greet2: #greet1, no necesita argumentos greet1 {puts'Hola'} #greet2, necesita un argumento greet2 ("argumento_cualquiera") {puts'Hola'} Lo usual es usar los parntesis para bloques de una lnea y el doend para ms de una lnea.

yield
Un mtodo puede usar el bloque mediante la palabra yield: defmetodo puts'Comienzo del metodo' yield yield puts'Final del metodo' end metodo{puts'Dentro del bloque'} La salida es: 'Comienzo del metodo' 'Dentro del bloque' 'Dentro del bloque' 'Final del metodo'

# primer yield # segundo yield

Lo que sucede es que en el momento que el intrprete llega al yield, se ejecuta el cdigo dentro del bloque, y luego se retorna al mtodo.

Argumentos en los bloques


En los bloques se pueden usar argumentos especificndolos dentro de dos barras verticales | |. Y si se usan, en el yield no podemos olvidar darles valor: defmetodo yield('hola', 99) end metodo{|str,num| putsstr + ' ' + num.to_s} #hola 99

Un bloque de cdigo devuelve un valor: el valor de la ltima expresin evaluada. Y este valor devuelto por yield, puede usarse dentro del mtodo que invoca el bloque.

Los procs
Los bloques no son objetos, pero pueden convertirse en ellos gracia a la clase Proc. Los objetos tipo proc son bloques que se han unido a un conjuto de variables locales. Esto se hace gracias al mtodolambda del mdulo Kernel. prc = lambda{ "hola" } Un bloque creado con lambda acta como un mtodo: si no especificas el nmero correcto de argumentos, no puedes llamar al bloque. La clase Proc tiene un mtodo para llamar al bloque: el mtodo call prc = lambda {puts'Hola'} prc.call#llamamos al bloque #otro ejemplo toast = lambda do puts'Gracias' end toast.call La salida es: Hola Gracias Para usar argumentos con lambda: aBlock = lambda { |x| puts x } aBlock.call'Hola Mundo!' La salida es: Hola Mundo! Los procs son muy tiles por que: y No puedes pasar mtodos dentro de otros mtodos (usarlos como argumentos); pero si puedes usar procs como argumentos. Los mtodos no pueden devolver otros mtodos; pero s pueden devolver un procs.

#uso de procs como argumentos def metod1 proc1 puts'Principio del metodo' proc1.call puts'Final del metodo' end hola = lambda do puts'Hola' end metod1 hola la salida es:

Principio del metodo Hola Final del metodo

Ms malabares con strings


Hay muchos mtodos en la clase String (no hay que memorizarlos todos; para algo est la documentacin) como: y y y y y y y reverse, que invierte los caracteres de un string length, que nos dice el nmero de caracteres de un string, incluyendo los espacios en blanco. upcase, que pone todos los caracteres en maysculas lowercase, que pone todos los caracteres en minsculas swapcase, pone los caracteres maysculas en minsculas y los minsculas en maysculas capitalize, pone el primer caracter de cada palabra en maysculas, y los dems en minsculas slice, da una parte de un string

Los mtodos upcase, downcase, swapcase y capitalize tienen su correspondiente mtodo bang, que modifican el string (upcase!, downcase!, swapcase!, y captalize!). Si no necesitas el string original, es bueno usarlo, por que salvars memoria; sobretodo si el string es largo. Cada vez que se se asigna a una variable un string, un nuevo objeto String es creado. Cmo es administrada la memoria en los strings? Hay una porcin separada para ellos? La clase String tiene ms de 75 mtodos. Leyendo la Gua de Uso de Ruby (Ruby User's Guide), dice "no tenemos en cuenta la memoria ocupada por un string. Prescindimos de cualquier administracin de memoria". Para saber todos los mtodos que tiene un String: y y y y String.methods, da una lista de todo los mtodos que tiene la clase String. String.methods.sort (sort=ordenar), da una lista ordenada alfabticamente de todos los mtodos. String.instance_methods.sort, da una lista ordenada de todo los mtodos de instancia (se explicar ms adelante) que tiene un String. String.instance_methods(false).sort, muestra una lista ordenada de todos los mtodos que pertanezcan exclusivamente a los Strings, pero no a las clases de las que desciende.

Comparando dos cadenas


Los strings tienen distintos mtodos para comparar su igualdad. El ms comn de ellos es ==. Otro mtodo es String.eql?, que devuelve el mismo resultado que ==. Y por ltimo est String.equal?, que comprueba si dos strings son el mismo objeto. Veamos el siguiente ejemplo: defcompara_strings(s1, s2, s3) #comprobamos si el contenido es igual if s1 == s2 puts'Ambos strings tienen el mismo contenido' else puts'Ambos strings NO tienen el mismo conenido' end if s1.eql?(s2) puts'Ambos strings tienen el mismo contenido' else puts'Ambos strings NO tienen el mismo conenido' end =begin ahora comprobamos si ambos objetos son iguales: dos objetos diferentes pueden tener el mismo contenido

=end if s1.equal?(s2) puts'Ambos strings son el mismo objeto' else puts'Ambos strings NO son el mismo objeto' end if s1.equal?(s3) puts'Ambos strings son el mismo objeto' else puts'Ambos strings NO son el mismo objeto' end end string1 = 'Jonathan' string2 = 'Jonathan' string3 = string1 compara_strings(string1,string2,string3)

Ejercicio
Dado un string, invertirlo palabra por palabra (en vez de letra por letra). Solucin Se puede usar String.split que nos da un array formado por las palabras del string. La clase Array tiene un mtodo reverse; de tal forma que puedes revertir el array antes de juntarlo para hacer un nuevo string: palabras = 'Tutorial de Ruby - fcil, sencillo y con fundamento' putspalabras.split(" ").reverse.join(" ")

Expresiones Regulares
Las expresiones regulares, aunque crticas, son una poderosa herramienta para trabajar con texto. Son usadas para reconocer patrones y procesar texto. Una expresin regular es una forma de especificar un patrn de caracteres, que ser buscado en un string. En Ruby, se crean las expresiones regulares entre //: son objetos del tipo Regexp y pueden ser manipuladas como tales. //.class# Regexp

La forma ms simple de encontrar si una expresin (tambin funciona con strings) est dentro de un string, es usar el mtodo match o el operador =~: m1 = /Ruby/.match("El futuro es Ruby") puts m1 # "Ruby", puesto que encontr la palabra puts m1.class# devuelve MatchData; devuelve "nil" si no se encuentra # operador {{**=~**}}: m2 = "El futuro es Ruby" =~ /Ruby/ puts m2 # 13 -> posicin donde empieza la palabra "Ruby"

Construyendo expresiones regulares


Cualquier caracter que vaya entre barras, se busca exactamente: /a/# se busca la letra a, y cualquier palabra que la contenga Algunos caracteres tienen un significado espcial en las expresiones regulares. Para evitar que se procesen, y poder buscarlos, se usa la secuencia de escape \. /\?/ La \ significa "no trates el siguiente carcter como especial". Los caracteres espciales incluyen: ^, $, ?, ., /, \, [, ], {, }, (, ), + y *.

El comodn . (punto)
Algunas veces, se busca cualquier caracter en una posicin determinada. Esto se logra gracias al . (punto). Un punto, busca cualquier carcter, excepto el de retorno de carro. /.azado/ Busca 'mazado' y 'cazado'. Tambin encuentra '%azado' y '8azado'. Por eso hay que tener cuidado al usar el punto: puede dar ms resultados que los deseados. Sin embargo, se pueden poner restricciones a los resultados, especificando las clases de caracteres buscadas.

Clases de caracteres
Una clase de carcter es una lista explcita de caracteres. Para ello se usan los corchetes: /[mc]azado/ De esta forma, especificamos la bsqueda de 'azado' precedido por 'c' o 'm': solamente buscamos 'mazado' o 'cazado'.

Dentro de los corchetes, se puede especificar un rango de bsqueda. /[a-z]/# encuentra cualquier minscula /[A-Fa-f0-9]/# encuentra cualquier nmero hexadecimal Algunas veces se necesita encontrar cualquier carcter menos aquellos de una lista especfica. Este tipo de bsqueda se realiza negando, usando ^ al principio de la clase. /[^A-Fa-f0-9]/# encuentra cualquier carcter, menos los hexadecimales Algunos caracteres son tan vlidos, que tienen su abreviacin.

Abreviaciones para clases de caracteres


Para encontrar cualquier nmero, estas dos expresiones son equivalentes: /[0-9]/ /\d/ Otras dos abreviaciones son: y y \w encuentra cualquier dgito, letra, o guin bajo (_). \s encuentra cualquier carcter espacio-en-blanco (characterwhitespace), como son un espacio, un tabulado y un retorno de carro.

Todas las abreviaciones precedentes, tambin tienen una forma negada. Para ello, se pone la misma letra en maysculas: /\D/# busca cualquier carcter que no sea un nmero /\W/# busca cualquier carcter que no sea una letra o guin bajo /\S/# busca un carcter que no sea un espacio en blanco.

Tabla resumen
expresin . [] \w \W \s \S significado cualquier caracter especificacin por rango. P.ej: [a-z], una letra de la a, a la z letra o nmero; es lo mismo que [0-9A-Za-z] cualquier carcter que no sea letra o nmero carcter de espacio; es lo mismo que [ \t\n\r\f] cualquier carcter que no sea de espacio

\d \D \b \b \B * + $ {m,n} ? () ||

nmero; lo mismo que [0-9] cualquier carcter que no sea un nmero retroceso (0x08), si est dentro de un rango lmite de palabra, si NO est dentro de un rango no lmite de palabra cero o ms repeticiones de lo que le precede una o ms repeticiones de lo que le precede fin de la lnea como menos m, y como mucho n repeticioes de lo que le precede al menos una repeticin de lo que le precede; lo mismo que {0,1} agrupar expresiones operador lgico O, busca lo de antes o lo despus

Si no se entiende alguna de las expresiones anteriores, lo que hay que hacer es probar. Por ejemplo, veamos el ltimo caso: la |. Supongamos que buscamos la palabra 'gato' o la palabra 'perro': /gato|perro/ El | es un "O lgico": se busca la palabra de la izquierda o la palabra de la derecha.

Una bsqueda con xito, devuelve un objeto MatchData


Cualquier bsqueda sucede con xito o fracasa. Empecemos con el caso ms simple: el fallo. Cuando intentas encontrar un string mediante un patrn, y el string no se encuentra, el resultado siempre esnil (nil = nada). /a/.match("b") # nil Sin embargo, si la bsqueda tiene xito se devuelve un objeto MatchData. Este objeto tiene un valor 'true' desde el punto de vista booleano, y adems almacena la informacin de lo encontrado: donde empieza (en qu carcter del string), qu porcin del string ocupa,Para poder usar esta informacin, hace falta almacenarla primero. Veamos un ejemplo donde buscamos un nmero de telfono dentro de un string:

string = "Mi nmero de telfono es (123) 555-1234." num_expr = /\((\d{3})\)\s+(\d{3})-(\d{4})/# expresin regular m = num_expr.match(string) # almacenamos bsqueda unless m puts"No hubo concordancias." exit end print"El string de la bsqueda es: " putsm.string# string donde se efecta la bsqueda print"La parte del string que concuerda con la bsqueda es: " puts m[0] # parte del string que concuerda con nuestra bsqueda puts"Las tres capturas:" 3.timesdo |index| # m.captures[index] - subcadenas encontradas (subcaden = () en la expresin) puts"Captura ##{index + 1}: #{m.captures[index]}" end puts"Otra forma para poner la primera captura: " print"Captura #1: " puts m[1] # cada nmero corresponde a una captura la salida es: El string de la bsqueda es: Mi nmero de telfono es (123) 555-1234. La parte del string que concuerda con la bsqueda es: (123) 555-1234 Las tres capturas: Captura #1: 123 Captura #2: 555 Captura #3: 1234 Otra forma de poner la primera captura Captura #1: 123 Para analizar la expresin regular, hay que prestar atencin a cmo estn agrupadas las bsquedas entre parntesis: num_expr = /\((\d{3})\)\s+(\d{3})-(\d{4})/ y y y y y \((\d{3})\) busca un grupo de tres nmeros (\d{3}), entre dos parntesis \(\) \s+ espacio en blanco una o varias veces (\d{3}) tres nmeros - signo menos (\d{4}) cuatro nmeros

Condicionales y bucles
if,else
En Ruby, nil y false significan falso, todo lo dems (incluyendo true, 0) significan verdadero. En Ruby, nil es un objeto: por tanto, tiene sus mtodos, y lo que es ms, puedes aadir los mtodos que se quieran. Veamos un ejemplo de if,else: xyz = 5 ifxyz>4 puts'La variable xyz es mayor que 4' puts'Puedo poner ms instrucciones dentro del if' ifxyz == 5 puts'Se puede anidar un bloque if,else,end dentro de otro' else puts"Parte del bloque anidado" end else puts'La variable xyz no es mayor que 5' puts'Tambin puedo poner mltiples sentencias' end

elsif
else se ejecutaba si la condicin en if no se cumpla. Para poder tomar ms decisiones, en funcin del valor de la variable, se usa elsif: #usando if,else anidados puts'Hola, cul es tu nombre?' STDOUT.flush nombre = gets.chomp puts'Hola, ' + nombre + '.' if nombre == 'Mojamuto' puts'Pedazo de nombre!!!' else ifname == 'Enjuto' puts'...este nombre no es moco de pavo...' end end #usando elsif puts'Hola, cul es tu nombre?' STDOUT.flush nombre = gets.chomp puts'Hola, ' + nombre + '.' if nombre == 'Mojamuto' puts'Pedazo de nombre!!!' elsif nombre == 'Enjuto' puts'...este nombre no es moco de pavo...' end #otra modificacin, usando el || ("o" lgico)

puts'Hola, cul es tu nombre?' STDOUT.flush nombre = gets.chomp puts'Hola, ' + nombre + '.' if nombre = 'Mojamuto' || 'Enjuto' puts'Pedazo de nombre!!!' end Adems de la igualdad, existen otros operadores condicionales:

== != >= <= > <

igual distinto mayor igual que menor igual que mayor que menor que

case
Esta instruccin es muy parecida al if: se crean una serie de condiciones, y se ejecuta la primera condicin que se cumpla. Por ejemplo: xyz = 10 ifxyz % 2 == 0 puts 'La variable xyz es par' else puts 'La variable xyz es impar' end es equivalente a: xyz = 10 par = case whenxyz % 2 == 0thentrue whenxyz % 2 != 0thenfalse end puts par

unless
Ruby tiene una forma contraria al if: la instruccin unless. Y digo contraria, por que en if se ejecutaba el bloque (do end) si se cumpla la condicin; con unless se ejecutar el bloque mientras NO se cumpla.

nombre = 'Pepe' unless nombre == 'Enjuto' puts'Ese nombre no tiene arte ninguno' end =begin Si el nombre no es Enjuto, siempre se ejecutar el bloque. =end

Ejercicios
Escribe un mtodo que pregunte por un ao, y sea capaz de: 1. decir si es, o no es bisiesto. 2. poner la cantidad de minutos que tiene el ao.

Bucles

while
Se pueden hacer bucles ( bucle = algo que se repite) con la instruccin while: # Loops var = 0 whilevar<10 putsvar.to_s var += 1 end

times
Este es un ejemplo de cmo en Ruby es todo un objeto, inclusive los nmeros. El mtodo times necesita dos cosas: 1. un nmero entero, del cul es el mtodo 2. un bloque Lo que hace times es iterar el bloque ese "nmero" de veces. 10.timesdo |num| putsnum end Fijarse, que la variable num va de 0 a 9; por lo tanto, el bloque se itera 10 veces.

Nmeros aleatorios

Ruby tiene con un generador de nmeros aleatores: el mtodo rand. Usando rand se obtiene un nmero aleatorio x, tal que 0 <= x < 1. Si se le d un parmetro, por ejemplo rand(5), entonces 0 <= x < 5. defcarta_aleatoria palos = %w{ corazones treboles picas diamantes} numero = %w{ 1 2 3 4 5 6 7 8 9 10 J Q K } #Quiero una carta aleatoria que tiene: # -un palo aleatorio # -un nmero aleatorio #palo aleatorio num = palos.length palo_aleat = rand(num) #numero aleatorio num_aleat = rand(numero.length) puts numero[num_aleat] + ' de ' + palos[palo_aleat] end #una carta aleatoria carta_aleatoria #10 cartas aleatorias 10.timesdo carta_aleatoria end #NOTA: la variable del bucle, #como no su usa en el bloque #no se define.

Você também pode gostar