Ruby en 20 minutos
Upcoming SlideShare
Loading in...5
×
 

Ruby en 20 minutos

on

  • 1,042 views

Otra Guia para aprender a programar con lenguaje de programación Ruby..., Let´s Go!!! A programar!!!!!

Otra Guia para aprender a programar con lenguaje de programación Ruby..., Let´s Go!!! A programar!!!!!

Statistics

Views

Total Views
1,042
Views on SlideShare
1,038
Embed Views
4

Actions

Likes
0
Downloads
16
Comments
0

2 Embeds 4

http://elrinconrubyalgomas.net76.net 3
http://www.slideshare.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

    • Upel - IPMProfesor: Este Blog y Contenido Fue realizado por:Eduardo Velasquez Yoelitza Mata Omar Landaeta Estiwarl Landaeta Sección 2 Creación de Web Blog
    • IntroducciónEste es un pequeño tutorial de Ruby que no debería tomar más de 20 minutoscompletarlo. Se asume que ya tienes instalado Ruby. Si no tienes Ruby funcionando en tuPC, descárgalo e instálalo antes de comenzar.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 “Hola Mundo” más cortodel mundo? No exactamente. La segunda linea sólo es la forma que tiene IRB paradecirnos el resultado de la última expresión evaluada. Si queremos que el programaescriba “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 siempre retorna nil, que es el valor que significa“absolutamente nada” en Ruby.Tu calculadora gratis está aquíPronto, tenemos suficiente para usar IRB como una calculadora básica:irb(main):003:0> 3+2=> 5
    • Tres más dos. Bastante fácil. ¿Y qué tal tres veces dos? Podrías escribirlo, es bastantecorto, pero también podrías subir y simplemente cambiar lo que ya ingresaste. Pruebapresionando la flecha hacia arriba en tu teclado y verifica si aparece la linea con 3+2escrito. 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=> 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 si quieres hacer loinverso 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 la raíz cuadrada denueve”, estás en lo cierto. Pero veamos las cosas un poco más de cerca. Antes que nada,¿qué es Math?Módulos, agrupa el código por tópicosMath es un módulo incluido para matemáticas. Los módulos tienen dos roles en Ruby.Esto muestra uno de sus roles: agrupar métodos similares bajo un nombre familiar. Mathtambién tiene métodos como sin() y tan().Después de Math hay un punto. ¿Cuál es la función del punto? El punto es la forma deidentificar al receptor de un mensaje. ¿Qué es un mensaje? En este caso es sqrt(9), quesignifica “llama al método sqrt”, abreviación de “square root” (raíz cuadrada) con elparámetro 9.El resultado de la llamada a este método es el valor 3.0. Notarás que no es simplemente 3.Eso es porque la mayoría de las veces la raíz cuadrada de un número no será un númeroentero, así que el método siempre retorna un número flotante.¿Y qué pasa si queremos recordar el resultado de algunas de estas operaciones? Asigna elresultado 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 alejando del tradicionalmensaje Hola Mundo en el que se supone que los cursos para principiantes debenenfocarse… así que volvamos a eso.¿Qué tal si queremos decir “Hola” muchas veces sin cansar nuestros dedos con el teclado?¡Necesitamos definir un método!irb(main):010:0> def 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 que estamos definiendoun método, cuyo nombre es h. La siguiente linea es el cuerpo del método, la mismaexpresión que vimos anteriormente: puts "Hola Mundo". Finalmente, la última linea endla dice a Ruby que terminamos 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ólo mencionar sunombre. Si el método no requiere parámetros para ejecutarse, eso es todo lo quenecesitas. Puedes agregar paréntesis vacíos, pero no son necesarios.¿Y qué tal si queremos saludar sólo a una persona y no a todo el mundo? Simplementeredefine h para que tome un nombre como pará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 en detalle qué es lo queestá sucediendo.Reservando espacios en un String¿Qué significa la expresión #{nombre}? Esa es la forma que tiene Ruby para insertar algoen un String. La expresión entre las llaves es transformada en un String (si todavía no lo es)y posteriormente sustituida en ese punto del String que la contiene. También puedes 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 estamos llamando al método sinutilizar los paréntesis. Si lo que quieres hacer es obvio, los paréntesis son opcionales. Elotro truco es el parámetro por defecto Mundo. Esto significa “si no se provee un nombre,utiliza el nombre por defecto "Mundo"”.
    • Convirtiéndolo en un Anfitrión¿Qué hacemos si queremos tener un anfitrión más “en serio”? Uno que recuerde tunombre, te dé la bienvenida y te trate con respeto. Puedes querer utilizar un objeto paraeso. 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 clase llamada Anfitrion y unpar de métodos para esa clase. También toma nota de @nombre. Esta es una variable deinstancia y está disponible para todos los métodos de la clase. Como puedes ver esutilizada por decir_hola y decir_adios.¿Así que cómo hacemos para que esta clase Anfitrion nos sea de utilidad? Crea un objeto.Ahora vamos a crear y usar un objeto anfitrión:irb(main):035:0> a = Anfitrion.new("Juan")=> #<Anfitrion:0x16cac @nombre="Juan">irb(main):036:0> a.decir_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 dela 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 :nombreirb(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 noniega 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_adiosendGuarda 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áspotentes 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.