• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Ruby en 20 minutos
 

Ruby en 20 minutos

on

  • 452 views

 

Statistics

Views

Total Views
452
Views on SlideShare
451
Embed Views
1

Actions

Likes
0
Downloads
1
Comments
0

1 Embed 1

http://lapaginafulruby.net46.net 1

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Ruby en 20 minutos Ruby en 20 minutos Document Transcript

    • Ruby en 20 minutosIntroducciónEste es un pequeño tutorial de Ruby que no debería tomar más de 20minutos completarlo. Se asume que ya tienes instalado Ruby. Si notienes Ruby funcionando en tu PC, descárgalo e instálalo antes decomenzar.Ruby interactivoArranca 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 “HolaMundo” más corto del mundo? No exactamente. La segunda linea sóloes la forma que tiene IRB para decirnos el resultado de la últimaexpresión evaluada. Si queremos que el programa escriba “Hola Mundo”necesitamos un poco más:irb(main):002:0> puts "Hola Mundo"Hola Mundo=> nilputs 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 siempreretorna 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=> 5Tres más dos. Bastante fácil. ¿Y qué tal tres veces dos? Podríasescribirlo, es bastante corto, pero también podrías subir y simplementecambiar lo que ya ingresaste. Prueba presionando la flecha haciaarriba en tu teclado y verifica si aparece la linea con 3+2 escrito. Si esasí, puedes usar la flecha hacia la izquierda para posicionarte junto alsigno + y cambiarlo por un *.irb(main):004:0> 3*2=> 6Ahora intentemos tres al cuadrado:irb(main):005:0> 3**2=> 9En Ruby ** es la forma que tienes para decir “elevado al”. ¿Y qué tal siquieres hacer lo inverso y encontrar la raíz cuadrada de algo?irb(main):006:0> Math.sqrt(9)=> 3.0Bien, esperen, ¿qué fue eso? Si adivinaste, “fue la forma de averiguar laraíz cuadrada de nueve”, estás en lo cierto. Pero veamos las cosas unpoco más de cerca. Antes que nada, ¿qué es Math?Módulos, agrupa el código por tópicosMath es un módulo incluido para matemáticas. Los módulos tienen dosroles en Ruby. Esto muestra uno de sus roles: agrupar métodossimilares bajo un nombre familiar. Math también tiene métodos comosin() y tan().Después de Math hay un punto. ¿Cuál es la función del punto? El puntoes la forma de identificar al receptor de un mensaje. ¿Qué es unmensaje? 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 noes 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étodosiempre retorna un número flotante.¿Y qué pasa si queremos recordar el resultado de algunas de estasoperaciones? Asigna el resultado a una variable.irb(main):007:0> a = 3 ** 2=> 9irb(main):008:0> b = 4 ** 2=> 16irb(main):009:0> Math.sqrt(a+b)=> 5.0Por más bueno que esté esto de la calculadora, nos estamos alejandodel tradicional mensaje Hola Mundo en el que se supone que los cursospara principiantes deben enfocarse… así que volvamos a eso.¿Qué tal si queremos decir “Hola” muchas veces sin cansar nuestrosdedos con el teclado? ¡Necesitamos definir un método!irb(main):010:0> def hirb(main):011:1> puts "Hola Mundo"irb(main):012:1> end=> nilLa expresión def h inicia la definición del método. Le dice a Ruby queestamos definiendo un método, cuyo nombre es h. La siguiente linea esel cuerpo del método, la misma expresión que vimos anteriormente:puts "Hola Mundo". Finalmente, la última linea end la dice a Ruby queterminamos de definir el método. La respuesta de Ruby => nil noscomunica que él sabe que terminamos de definir el método.Las breves y repetitivas vidas de un métodoAhora intentemos ejecutar ese método algunas veces:irb(main):013:0> hHola Mundo=> nilirb(main):014:0> h()Hola Mundo=> nilBien, eso fue fácil. Ejecutar un método en Ruby es tan fácil como sólomencionar su nombre. Si el método no requiere parámetros para
    • ejecutarse, eso es todo lo que necesitas. Puedes agregar paréntesisvacíos, pero no son necesarios.¿Y qué tal si queremos saludar sólo a una persona y no a todo elmundo? Simplemente redefine h para que tome un nombre comoparámetro.irb(main):015:0> def h(nombre)irb(main):016:1> puts "Hola #{nombre}"irb(main):017:1> end=> nilirb(main):018:0> h("Matz")Hola Matz=> nilAsí que eso funciona… pero tomémonos un segundo para ver más endetalle qué es lo que está sucediendo.Reservando espacios en un String¿Qué significa la expresión #{nombre}? Esa es la forma que tiene Rubypara insertar algo en un String. La expresión entre las llaves estransformada en un String (si todavía no lo es) y posteriormentesustituida en ese punto del String que la contiene. También puedes usaresto 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=> nilirb(main):022:0> h "pedro"Hola Pedro=> nilirb(main):023:0> hHola Mundo=> nilAlgunos otros trucos para destacar. Uno es que otra vez estamosllamando al método sin utilizar los paréntesis. Si lo que quieres hacer esobvio, los paréntesis son opcionales. El otro truco es el parámetro pordefecto Mundo. Esto significa “si no se provee un nombre, utiliza elnombre por defecto "Mundo"”.Convirtiéndolo en un Anfitrión¿Qué hacemos si queremos tener un anfitrión más “en serio”? Uno querecuerde tu nombre, te dé la bienvenida y te trate con respeto. Puedesquerer utilizar un objeto para eso. Vamos a crear la clase “Anfitrion”.
    • irb(main):024:0> class Anfitrionirb(main):025:1> def initialize(nombre = "Mundo")irb(main):026:2> @nombre = nombreirb(main):027:2> endirb(main):028:1> def decir_holairb(main):029:2> puts "Hola #{@nombre}"irb(main):030:2> endirb(main):031:1> def decir_adiosirb(main):032:2> puts "Adiós #{@nombre}, vuelve pronto."irb(main):033:2> endirb(main):034:1> end=> nilLa nueva palabra clave aquí es class. Esto define una nueva clasellamada Anfitrion y un par de métodos para esa clase. También tomanota de @nombre. Esta es una variable de instancia y está disponible paratodos los métodos de la clase. Como puedes ver es utilizada pordecir_hola y decir_adios.¿Así que cómo hacemos para que esta clase Anfitrion nos sea deutilidad? 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_holaHola Juan=> nilirb(main):037:0> a.decir_adiosAdiós Juan, vuelve pronto.=> nilUna 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.@nombreSyntaxError: compile error(irb):52: syntax error from (irb):52No, no podemos.Por debajo de la piel del objetoLas variables de instancia se esconden dentro del objeto. No están tanescondidas, las puedes ver cuando inspeccionas el objeto, y hay otrasformas de acceder a ellas, pero Ruby es fiel a las buenas costumbres de
    • la programación orientada a objetos manteniendo los datos lo másprivados 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 dosmétodos. ¿Qué es lo que está sucediendo? Bueno, estos son todos losmétodos para los objetos Anfitrion, una lista completa, incluyendo losque están definidos en las superclases de Anfitrion. Si queremos listarúnicamente los métodos definidos para la clase Anfitrion podemospedirle que no incluya sus ancestros pasándole el parámetro false, quesignifica 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 respondernuestro objeto anfitrión:irb(main):041:0> a.respond_to?("nombre")=> falseirb(main):042:0> a.respond_to?("decir_hola")=> trueirb(main):043:0> a.respond_to?("to_s")=> trueAsí que, sabe decir_hola, y to_s (que significa “convertir algo en unstring”, un método que está definido por defecto para todos losobjetos), pero no reconoce nombre como un método.Modificando clases—Nunca es demasiado tarde¿Pero qué pasa si quieres poder ver o modificar el nombre? Ruby proveeuna forma fácil para permitir acceder a las variables de un objeto.irb(main):044:0> class Anfitrionirb(main):045:1> attr_accessor :nombre
    • irb(main):046:1> end=> nilEn Ruby, puedes volver a abrir una clase y modificarla. Eso no cambiaobjetos que ya existan, pero afecta a los nuevos objetos que puedascrear. Así que vamos a crear un nuevo objeto y juguemos con supropiedad @nombre.irb(main):047:0> a = Anfitrion.new("Pedro")=> #<Anfitrion:0x3c9b0 @nombre="Pedro">irb(main):048:0> a.respond_to?("nombre")=> trueirb(main):049:0> a.respond_to?("nombre=")=> trueirb(main):050:0> a.decir_holaHola Pedro=> nilirb(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_holaHola Matilde=> nilEl uso de attr_accessor determinó que se definan dos nuevos métodospor 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 puedetrabajar con una persona a la vez. ¿Qué pasaría si tuviéramos algunaclase MegaAnfitrion que pudiera saludar al mundo, a una persona, o unalista completa de personas?Escribamos esto en un archivo en vez de usar directamente el intérpreteinteractivo de Ruby IRB.Para salir de IRB, escribe “quit”, “exit” o simplemente presiona Control-D.#!/usr/bin/env rubyclass 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 endendif __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 ma.decir_adiosend
    • Guarda este archivo como “ri20min.rb”, y ejecútalo con “rubyri20min.rb”. El resultado debería ser:Hola MundoAdiós Mundo. Vuelve pronto.Hola DiegoAdiós Diego. Vuelve pronto.Hola AlbertoHola BeatrizHola CarlosHola DavidHola ErnestoAdiós Alberto, Beatriz, Carlos, David, Ernesto. Vuelvan pronto.......Hay un montón de cosas nuevas en este nuevo ejemplo en las quepodemos echar una mirada más profunda.Así que, investigando nuestro programa, notarás que las primeras lineascomienzan con un numeral (#). En Ruby, todo lo que esté detrás de unnumeral es un comentario y es ignorado por el intérprete. La primerlinea del archivo es un caso especial y en los sistemas operativos delestilo Unix determina cómo ejecutar el archivo. El resto de loscomentarios están únicamente para aportar claridad al significado delcódigo.Nuestro método decir_hola se ha vuelto un poco más complicado:# Decirle hola a todosdef 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}" endendAhora usa el atributo @nombres para tomar decisiones. Si es nil, sóloimprime tres puntos. No hay razón para saludar a nadie, ¿cierto?
    • IterandoSi el objeto @nombres responde al método each, es algo sobre lo que sepuede iterar, así que iteramos entre sus elementos y saludamos a cadauno de sus integrantes. Finalmente, si @nombres es otra cosa, dejamosque automáticamente se convierta en un string y usamos el saludo pordefecto.Veamos ese iterador en más detalle:@nombres.each do |nombre| puts "Hola #{nombre}"endEl método each acepta un bloque de código y lo ejecuta por cadaelemento 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 lospipes (|) es el parámetro para este bloque.Lo que sucede es que por cada elemento en la lista, nombre va tomandosu valor y se ejecuta la expresión puts "Hola #{nombre}" con ese nombre.Muchos otros lenguajes de programación manejan la iteración de unalista 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 variabledescartable como i, averiguar la cantidad de elementos de la lista, yexplicar cómo recorrerla. La costumbre Ruby (The Ruby Way) es muchomás elegante, todos los detalles de infraestructura se ocultan en elmétodo each, todo lo que necesitas hacer es decirle qué hacer con cadaelemento. 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 RubyEl poder real de los bloques se disfruta al trabajar con cosas máscomplicadas que las listas. Más allá de manejar los detalles deinfraestructura dentro del método, también puedes manejar lainicialización, la finalización, y los errores—todos ocultos y simplificadosfrente a las preocupaciones del desarrollador.
    • # Decirle adiós a todosdef 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." endendEl método decir_adios no usa each, en vez de eso se fija si @nombresresponde al método join, y si es así, lo usa. Si no es así, simplementeimprime la variable como un string. Esta práctica de no preocuparsesobre el tipo de objeto de una variable, y simplemente depender de losmétodos que esta soporta, es conocida como “Duck Typing”. El beneficioes que no limita innecesariamente los tipos de variables que sonsoportados. Si alguien inventa un nuevo tipo de lista, siempre y cuandoimplemente el método join con la misma semántica que otras listas,todo funcionará como fue planeado.Arrancando el ScriptAsí que eso es la clase MegaAnfitrion, el resto del archivo sólo llama alos métodos de la clase. Hy un último truco para tener en cuenta, y es lalinea:if __FILE__ == $0__FILE__ es la variable mágica que contiene el nombre del archivo que seestá ejecutando en ese momento. $0 es el nombre del archivo usadopara iniciar el programa. Esta verificación dice “si este es el archivoprincipal…”. Esto permite que un archivo sea utilizado como unabiblioteca, 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 iniciadoEso es todo en este rápido paseo por Ruby. Hay mucho más porexplorar, las estructuras de control diferentes que ofrece Ruby; el uso elos bloques y yield; módulos como mixins; y más. Espero que estapequeñ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, dondeencontrarás vínculos a cursos y manuales, todos disponiblesgratuitamente en internet.O si realmente te gustaría sumergirte en un libro, busca en el listado delibros los títulos disponibles para venta en linea o en tu tienda favorita.