• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Ruby en linux
 

Ruby en linux

on

  • 651 views

 

Statistics

Views

Total Views
651
Views on SlideShare
648
Embed Views
3

Actions

Likes
0
Downloads
4
Comments
0

1 Embed 3

http://vilnaupelinfor.net46.net 3

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 linux Ruby en linux Document Transcript

    • Ruby en LinuxDependiendo de la distribución que utilices, hay varias maneras deinstalar Ruby. La primer opción es simplemente bajar el código fuentey compilarlo a mano. Pero en algunas plataformas, hay gestores depaquetes que hacen la instalación de Ruby extremadamente sencilla.Debian/Ubuntu:% sudo apt-get install ruby irb rdocArchlinux:# pacman -S rubyGentoo/Sabayon/Funtoo Linux:# emerge rubyAcerca de Ruby¿Te preguntas por qué Ruby es tan popular? Sus fanáticos lo tienencomo un lenguaje hermoso y artístico. Y todavía así, dicen que espráctico y ameno. ¿Por qué?Los ideales del creador de RubyRuby es un lenguaje con un balance cuidado. Su creador, Yukihiro―matz‖ Matsumoto, mezcló partes de sus lenguajes favoritos (Perl,Smalltalk, Eiffel, Ada, y Lisp) para formar un nuevo lenguaje queincorporara tanto la programación funcional como la programaciónimperativa.
    • A menudo ha manifestado que está ―tratando de hacer que Ruby seanatural, no simple‖, de una forma que se asemeje a la vida real.Continuando sobre esto, agrega:Ruby es simple en apariencia, pero complejo por dentro, como elcuerpo humano1.Acerca del crecimiento de RubyDesde su liberación pública en 1995, Ruby ha atraído devotosdesarrolladores de todo el mundo. En el 2006, Ruby alcanzóreconocimiento masivo, formándose grupos de usuarios activos en lasciudades más importantes del mundo y llenando las capacidades delas conferencias relacionadas a Ruby.Ruby-Talk, la lista de correo más importante sobre el lenguaje Rubyha crecido hasta lograr un promedio de 200 mensajes por día.El índice TIOBE, que mide el crecimiento de los lenguajes deprogramación, ubica a Ruby en la posición #13 del ranking mundial.Refiriéndose a su crecimiento, predicen, ―Todo indica que Rubyllegará a estar entre los 10 primeros en menos de 6 meses‖. Granparte de su crecimiento se atribuye a la popularidad alcanzada poraplicaciones desarrolladas con Ruby, en particular el framework dedesarrollo web Ruby on Rails2.Ruby es totalmente libre. No sólo gratis, sino también libre parausarlo, copiarlo, modificarlo y distribuirlo.Viendo todo como un objetoInicialmente, Matz buscó en otros lenguajes para encontrar la sintaxisideal. Recordando su búsqueda, dijo, ―quería un lenguaje que fueramás poderoso que Perl, y más orientado a objetos que Python3‖.En Ruby, todo es un objeto. Se le puede asignar propiedades yacciones a toda información y código. La programación orientada aobjetos llama a las propiedades variables de instancia y las accionesson conocidas como métodos. La orientación a objetos pura de Ruby
    • se suele demostrar con un simple código que aplica una acción a unnúmero.5.times { print "Nos *encanta* Ruby -- ¡es fuera de serie!" }En muchos lenguajes, los números y otros tipos primitivos no sonobjetos. Ruby sigue la influencia del lenguaje Smalltalk pudiendoponer métodos y variables de instancia a todos sus tipos de datos.Esto facilita el uso de Ruby, porque las reglas que se aplican a losobjetos son aplicables a todo Ruby.La flexibilidad de RubyRuby es considerado un lenguaje flexible, ya que permite a sususuarios alterarlo libremente. Las partes esenciales de Ruby puedenser quitadas o redefinidas a placer. Se puede agregar funcionalidad apartes ya existentes. Ruby intenta no restringir al desarrollador.Por ejemplo, la suma se realiza con el operador suma (+). Pero siprefieres usar la palabra sumar, puedes agregar un método llamadosumar a la clase Numeric que viene incorporada.class Numeric def sumar(x) self.+(x) endendy = 5.sumar 6# ahora y vale 11Los operadores de Ruby son simples conveniencias sintácticas paralos métodos. Los puedes redefinir como y cuando quieras.Los Bloques, una funcionalidad realmente expresivaLos bloques de Ruby son también vistos como una fuente de granflexibilidad. El desarrollador puede anexar una cláusula a cualquiermétodo, describiendo cómo debe actuar. La cláusula es llamadabloque y se ha convertido en una de las más famosas funcionalidadespara los recién llegados a Ruby que vienen de otros lenguajesimperativos como PHP o Visual Basic.Los bloques están inspirados por los lenguajes funcionales. Matz dijo,―en las cláusulas de Ruby, quise respetar la cultura de Lisp4‖.motores_de_busqueda = %w[Google Yahoo MSN].map do |motor| "http://www." + motor.downcase + ".com" end
    • En este código, el bloque está descrito entre la construcción do ...end. El método map aplica el bloque a la lista de palabras provista.Muchos otros métodos en Ruby dejan abierta la posibilidad aldesarrollador para que escriba su propio bloque describiendo losdetalles de qué debe hacer ese método.Ruby y el MixinA diferencia de otros lenguajes de programación orientada a objetos,Ruby se caracteriza por su intencional herencia simple. Sin embargo,Ruby incorpora el concepto de módulos (llamados categorías enObjective-C), que son colecciones de métodos.Las clases pueden mezclar (mixin) un módulo e incorporar todos susmétodos gratuitamente. Por ejemplo, cualquier clase que implementeel método each puede incorporar el módulo Enumerable, que le agregaun conjunto de métodos que usan each para recorrer sus elementos.class MiArray include EnumerableendEn general, los Rubyistas ven esto como una forma mucho más clarade herencia múltiple, que es compleja e incluso puede ser restrictiva.La apariencia visual de RubyA pesar de que Ruby utiliza la puntuación muy limitadamente y seprefieren las palabras clave en inglés, se utiliza algo de puntuaciónpara decorar el código. Ruby no necesita declaraciones de variables.Se utilizan convenciones simples para nombrar y determinar elalcance de las mismas.  var puede ser una variable local.  @var es una variable de instancia.  $var es una variable global.Estos detalles mejoran la legibilidad permitiendo que el desarrolladoridentifique fácilmente los roles de las variables. También se haceinnecesario el uso del molesto self. como prefijo de todos losmiembros de instancia.Más allá de lo básicoRuby tiene un conjunto de otras funcionalidades entre las que seencuentran las siguientes:  manejo de excepciones, como Java y Python, para facilitar el manejo de errores.
    •  un verdadero mark-and-sweep garbage collector para todos los objetos de Ruby. No es necesario mantener contadores de referencias en bibliotecas externas. Como dice Matz, ―Esto es mejor para tu salud‖.  escribir extenciones en C para Ruby es más fácil que hacer lo mismo para Perl o Python, con una API muy elegante para utilizar Ruby desde C. Esto incluye llamadas para embeber Ruby en otros programas, y así usarlo como lenguaje de scripting. También está disponible una interfaz SWIG.  puede cargar bibliotecas de extensión dinámicamente si lo permite el sistema operativo.  tiene manejo de hilos (threading) independiente del sistema operativo. De esta forma, tienes soporte multi-hilo en todas las plataformas en las que corre Ruby, sin importar si el sistema operativo lo soporta o no, ¡incluso en MS-DOS!  Ruby es fácilmente portable: se desarrolla mayoritariamente en GNU/Linux, pero corre en varios tipos de UNIX, Mac OS X, Windows 95/98/Me/NT/2000/XP, DOS, BeOS, OS/2, etc.Referencias1 Matz, hablando en la lista de correo Ruby-Talk, 12 de mayo del2000.2 Mira la página de Ruby on Rails para averiguar más.3 Matz, en An Interview with the Creator of Ruby, 29 de noviembredel 2001.4 Matz, en Blocks and Closures in Ruby, 22 de diciembre del 2003.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―Hola Mundo‖ más corto del mundo? No exactamente. La segundalinea sólo es la forma que tiene IRB para decirnos el resultado de laúltima expresió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‖ enRuby.Tu calculadora gratis está aquíPronto, tenemos suficiente para usar IRB como una calculadorabá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 ysimplemente cambiar lo que ya ingresaste. Prueba presionando laflecha hacia arriba en tu teclado y verifica si aparece la linea con3+2 escrito. Si es así, puedes usar la flecha hacia la izquierda paraposicionarte junto al signo + y cambiarlo por un *.irb(main):004:0> 3*2=> 6
    • Ahora intentemos tres al cuadrado:irb(main):005:0> 3**2=> 9En Ruby ** es la forma que tienes para decir ―elevado al‖. ¿Y qué talsi quieres 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 averiguarla raíz cuadrada de nueve‖, estás en lo cierto. Pero veamos las cosasun 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 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? Elpunto es la forma de identificar al receptor de un mensaje. ¿Qué esun mensaje? En este caso es sqrt(9), que significa ―llama al métodosqrt‖, abreviación de ―square root‖ (raíz cuadrada) con el parámetro9.El resultado de la llamada a este método es el valor 3.0. Notarás queno es simplemente 3. Eso es porque la mayoría de las veces la raízcuadrada 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 lineaes el cuerpo del método, la misma expresión que vimosanteriormente: puts "Hola Mundo". Finalmente, la última linea end ladice a Ruby que terminamos de definir el método. La respuesta deRuby => nil nos comunica que él sabe que terminamos de definir elmé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 paraejecutarse, 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 puedesusar esto 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 haceres obvio, los paréntesis son opcionales. El otro truco es el parámetropor defecto 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‖? Unoque recuerde tu nombre, te dé la bienvenida y te trate con respeto.Puedes querer utilizar un objeto para eso. Vamos a crear la clase―Anfitrion‖.irb(main):024:0> class 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á disponiblepara todos 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_adios
    • Adiós Juan, vuelve pronto.=> nilUna vez que el objeto a es creado, nos recuerda que el nombre esJuan. 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ántan escondidas, las puedes ver cuando inspeccionas el objeto, y hayotras formas de acceder a ellas, pero Ruby es fiel a las buenascostumbres de la programación orientada a objetos manteniendo losdatos lo más privados 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 todoslos métodos para los objetos Anfitrion, una lista completa, incluyendolos que están definidos en las superclases de Anfitrion. Si queremoslistar únicamente los métodos definidos para la clase Anfitrionpodemos pedirle que no incluya sus ancestros pasándole elparámetro false, que significa que no queremos los métodosdefinidos 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 puederesponder nuestro 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? Rubyprovee una forma fácil para permitir acceder a las variables de unobjeto.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 nocambia objetos que ya existan, pero afecta a los nuevos objetos quepuedas crear. Así que vamos a crear un nuevo objeto y juguemos consu propiedad @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 anadie!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 alguna
    • clase MegaAnfitrion que pudiera saludar al mundo, a una persona, ouna lista completa de personas?Escribamos esto en un archivo en vez de usar directamente elintérprete interactivo de Ruby IRB.Para salir de IRB, escribe ―quit‖, ―exit‖ o simplemente presionaControl-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 primeraslineas comienzan con un numeral (#). En Ruby, todo lo que estédetrás de un numeral es un comentario y es ignorado por elintérprete. La primer linea del archivo es un caso especial y en lossistemas operativos del estilo Unix determina cómo ejecutar elarchivo. El resto de los comentarios están únicamente para aportarclaridad al significado del có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 acada uno de sus integrantes. Finalmente, si @nombres es otra cosa,dejamos que automáticamente se convierta en un string y usamos elsaludo por defecto.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 variableentre los pipes (|) es el parámetro para este bloque.Lo que sucede es que por cada elemento en la lista, nombre vatomando su valor y se ejecuta la expresión puts "Hola #{nombre}" conese 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) esmucho más elegante, todos los detalles de infraestructura se ocultanen el método each, todo lo que necesitas hacer es decirle qué hacercon cada elemento. 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 ysimplificados frente 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 delos métodos que esta soporta, es conocida como ―Duck Typing‖. Elbeneficio es que no limita innecesariamente los tipos de variables queson soportados. Si alguien inventa un nuevo tipo de lista, siempre ycuando implemente el método join con la misma semántica que otraslistas, 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, yes la linea:if __FILE__ == $0__FILE__ es la variable mágica que contiene el nombre del archivo quese está ejecutando en ese momento. $0 es el nombre del archivousado para iniciar el programa. Esta verificación dice ―si este es elarchivo principal…‖. Esto permite que un archivo sea utilizado comouna biblioteca, y no ejecutar código en ese contexto. Pero si elarchivo está siendo usado como un ejecutable, entonces ejecuta esecó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 usoe los 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 listadode libros los títulos disponibles para venta en linea o en tu tiendafavorita.Ruby desde otros lenguajesCuando te enfrentas por primera vez a código escrito en Ruby,probablemente te recuerde otros lenguajes que hayas usado. Esto esa propósito. La mayor parte de la sintaxis es familiar para losusuarios de Perl, Python, y Java (entre otros lenguajes), así que sihas usado alguno de estos, aprender Ruby será muy fácil.Este documento contiene dos secciones. La primera intenta ser unresumen de lo que puedes esperar ver al aprender Ruby viniendo deotro lenguaje. La segunda sección se enfoca en determinadasfuncionalidades del lenguaje y cómo podrían compararse a lo que yapuedas estar familiarizado.Qué esperar: Lenguaje X a Ruby  A Ruby desde Java  A Ruby desde PHPEstamos en proceso de traducir todos estos artículos, pero mientraslo hacemos no queremos privarte de que los leas en inglés:  To Ruby From C and C++ (en inglés)  To Ruby From Java (en inglés)  To Ruby From Perl (en inglés)  To Ruby From PHP (en inglés)  To Ruby From Python (en inglés)Funcionalidades importantes del lenguaje y algunas advertenciasAquí tienes algunas referencias y consejos sobre funcionalidades deRuby que verás mientras lo aprendes.
    • IteraciónDos funcionalidades de Ruby que se diferencian de lo que puedeshaber visto previamente, y que toma cierto tiempo acostumbrarse aellas, son los ―bloques‖ e iteradores. En vez de recorrer un índice(como con C, C++, o Java anterior al 1.5), o recorrer una lista (comoel for (@a) {...} de Perl, o for i in aList: ... en Python, con Rubyverás muy frecuentemente código de este estilo:una_lista.each do |este_item| # Estamos dentro del bloque. # Trabaja con este_item.endPara obtener más información sobre each (y sus amigos collect, find,inject, sort, etc.), ejecuta ri Enumerable (y después riEnumerable#nombre_del_metodo).Todo tiene un valorNo hay diferencia entre una expresión y un comando. Todo tiene unvalor, incluso si ese valor es nil. Esto es posible:x = 10y = 11z = if x < y trueelse falseendz # => trueLos symbols (símbolos) no son strings especialesA muchos novatos en Ruby les cuesta entender qué son los symbols,y qué utilidad pueden tener.Los symbols pueden ser descritos como identidades. Lo importante deun Symbol es quién es, no qué es. Arranca irb y experimenta ladiferencia:irb(main):001:0> :jorge.object_id == :jorge.object_id=> trueirb(main):002:0> "jorge".object_id == "jorge".object_id=> falseirb(main):003:0>El método object_id retorna la identidad de un objeto. Si dos objetostienen el mismo object_id, son el mismo objeto (apuntan al mismoobjeto en la memoria).
    • Como puedes ver, una vez que has usado un Symbol, cualquier otroSymbol con los mismos caracteres referencia al mismo objeto enmemoria. Para dos symbols que representan los mismos caracteres,el object_id es el mismo.Ahora veamos el String (―jorge‖). El object_id no es el mismo. Esosignifica que representan a dos objetos diferentes en memoria.Siempre que uses un nuevo String, Ruby reserva memoria para él.Si tienes dudas sobre usar un Symbol o un String, considera qué esmás importante: la identidad de un objeto (por ejemplo la Key de unHash), o el contenido (en nuestro ejemplo, ―jorge‖).Todo es un objeto―Todo es un objeto‖ no es una exageración. Incluso las clases y losenteros son objetos, y puedes hacer con ellos las mismas cosas quecon cualquier otro objeto:# Esto es lo mismo que:# class MiClase# attr_accessor :variable_de_instancia# endMiClase = Class.new do attr_accessor :variable_de_instanciaendConstantes variablesLas constantes no son realmente… constantes. Si modificas unaconstante previamente inicializada, Ruby disparará una advertencia,pero no detendrá tu programa. De todas formas, eso no quiere decirque deberías redefinir tus constantes.Convenciones de sintaxisRuby impone algunas convenciones de sintaxis. Si un identificadorcomienza con una letra mayúscula, es una constante. Si comienzacon un símbolo de moneda ($), es una variable global. Si comienzacon @, es una variable de instancia. Si comienza con @@, es unavariable de clase.Sin embargo, los nombres de los métodos tienen permitido comenzarcon letras mayúsculas. Esto puede confundirte, como muestra elsiguiente ejemplo:Constante = 10def Constante 11end
    • Ahora Constante vale 10, pero Constante() retorna 11.Falsos parámetros nombradosA diferencia de Python, Ruby no tiene parámetros nombrados. Sinembargo, pueden ser emulados mediante el uso de symbols yhashes. Ruby on Rails, entre otros, usa esto a discreción. Porejemplo:def parametros_con_nombre( params ) paramsendparametros_con_nombre( :param_uno => 10, :param_dos => 42 )# => {:param_uno=>10, :param_dos=>42}La verdad universalEn Ruby, todo excepto nil y false es considerado true. En C, Pythony muchos otros lenguajes, 0* y posiblemente otros valores, comolistas vacías, son considerados *false. Examina el siguientecódigo Python (el ejemplo aplica también a otros lenguajes):# en Pythonif 0: print "0 es verdadero"else: print "0 es falso"Esto imprimirá ―0 es falso‖. El equivalente en Ruby:# en Rubyif 0 puts "0 es verdadero"else puts "0 es falso"endImprime ―0 es verdadero‖.Los modificadores de acceso aplican hasta el fin del alcanceEn el siguiente código Ruby,class MiClase private def un_metodo; true; end def otro_metodo; false; endendPuede ser que esperes que otro_metodo sea de alcance público. Estono es así. El modificador de acceso ‗private‘ continúa hasta el fin del
    • alcance, o hasta que aparezca un nuevo modificador de acceso, loque ocurra primero. Por defecto, los métodos son públicos:class MiClase # Ahora un_metodo es público def un_metodo; true; end private # otro_metodo es privado def otro_metodo; false; endendpublic, private y protected en realidad son métodos, así que pueden recibirparámetros. Si pasas un símbolo a uno de ellos, la visibilidad de ese métodoes alterada.Acceso a los métodosEn Java, public significa que un método puede ser accedido porcualquiera. protected significa que las instancias de la clase,instancias de sus descendientes así como también de clases en elmismo paquete, pueden accederlo, pero nadie más. Y private significaque los métodos son accesibles únicamente desde las instancias de laclase.En Ruby esto es un poco diferente. public es, naturalmente, público.private significa que los métodos son accesibles sólo cuando puedenser invocados sin un receptor explícito. Sólo self tiene permitido serel receptor de la invocación a un método privado.Al que debemos estar atentos es a protected. Un método protegidopuede ser llamado desde una instancia de una clase o las instanciasde sus ancestros, pero también con otra instancia como su receptor.Ejemplo, adaptado del Ruby FAQ:$ irbirb(main):001:0> class Testirb(main):002:1> # public por defectoirb(main):003:1* def funcirb(main):004:2> 99irb(main):005:2> endirb(main):006:1>irb(main):007:1* def ==(otro)irb(main):008:2> func == otro.funcirb(main):009:2> endirb(main):010:1> end=> nilirb(main):011:0>irb(main):012:0* t1 = Test.new=> #<Test:0x34ab50>irb(main):013:0> t2 = Test.new=> #<Test:0x342784>
    • irb(main):014:0> t1 == t2=> trueirb(main):015:0> # ahora haz func protected, todavía funcionairb(main):016:0* # porque protected permite la otra referenciairb(main):017:0* class Testirb(main):018:1> protected :funcirb(main):019:1> end=> Testirb(main):020:0> t1 == t2=> trueirb(main):021:0> # ahora haz func privateirb(main):022:0* class Testirb(main):023:1> private :funcirb(main):024:1> end=> Testirb(main):025:0> t1 == t2NoMethodError: private method `func called for #<Test:0x342784> from (irb):8:in `== from (irb):25 from :0irb(main):026:0>Las clases están abiertasLas clases de Ruby están abiertas.Puedes abrirlas, agregarlesfuncionalidad, y modificarlas en cualquier momento. Incluso lasclases principales, como Fixnum o incluso Object, el padre de todos losobjetos. Ruby on Rails define un montón de métodos para menejar eltiempo y los horarios en Fixnum. Mira:class Fixnum def hours self * 3600 # cantidad de segundos en una hora end alias hour hoursend# 14 horas desde las 00:00 del 1ro de enero del 2006Time.mktime(2006, 01, 01) + 14.hours # => Sun Jan 01 14:00:00Nombres de métodos graciososEn Ruby, los métodos tienen permitido terminar en signos deexclamación o interrogación. Por convención, los métodos queresponden preguntas (i.e. Array#empty? retorna true si el receptorestá vacío) terminan con un signo de interrogación. Métodospotencialmente ―peligrosos‖ (i.e. métodos que modifican self o susargumentos, exit! etc.) por convención terminan en un signo deexclamación.De todas formas, no todos los métodos que modifican susargumentos terminan en signos de exclamación. Array#replacereemplaza el contenido de un array co nel contenido de otro array.
    • No tiene mucho sentido tener un método como ese que no modifiqueself.Los métodos SingletonLos métodos Singleton son métodos-por-objeto. Sólo estándisponibles en el objeto en el que los defines.class Automovil def inspect "Auto barato" endendporsche = Automovil.newporsche.inspect # => Auto baratodef porsche.inspect "Auto muy caro"endporsche.inspect # => Auto muy caro# Otros objetos no son afectadosotro_auto = Automovil.newotro_auto.inspect # => Auto baratoMétodos faltantesRuby no se rinde si no puede encontrar un método que responda a unmensaje en particular. Llama al método method_missing con el nómbredel método que no pudo encontrar y sus argumentos. Por defecto,method_missing lanza una excepción NameError, pero puedesredefinirlo para que se ajuste mejor a tu aplicación, y muchasbibliotecas lo hacen. Aquí tienes un ejemplo:# id es el nombre del método invocado, la sintaxis * recolecta# todos los argumentos en un array llamado argumentosdef method_missing( id, *argumentos ) puts "El método #{id} fue invocado, pero no existe. Tiene" + "estos argumentos: #{argumentos.join(", ")}"end__ :a, :b, 10# => El método __ fue invocado, pero no existe. Tiene estos# argumentos: a, b, 10Este código sólo imprime los detalles de la invocación, pero eres librede manejar el mensaje como te parezca más apropiado.Pasaje de mensajes, no llamadas a funcionesUna invocación a un método en realidad es un mensaje a otroobjeto:
    • # Esto1 + 2# Es lo mismo que esto ...1.+(2)# Que es lo mismo que esto:1.send "+", 2Los bloques son objetos, sólo que todavía no lo sabenLos bloques (cierres en realidad) son muy utilizados por la bibliotecaestandar. Para llamar a un bloque, puedes usar yield, o transformarloen un Proc al anexarle un parámetro especial a la lista deargumentos, así:def block( &el_bloque ) # Aquí dentro, el_bloque es el bloque pasado al método el_bloque # retornar el bloqueendsumador = block { |a, b| a + b }# sumador ahora es un objeto Procsumador.class # => ProcTambién puedes crear bloques fuera de las invocaciones a métodos,utilizando Proc.new con un bloque o llamando al método lambda.Similarmente, los métodos también pueden ser objetos:method(:puts).call "¡puts es un objeto!"# => ¡puts es un objeto!Los operadores son comodidades sintácticasLa mayoría de los operadores en Ruby son simples simplificacionessintácticas (con algunas reglas de precedencia) para llamar a ciertosmétodos. Puedes, por ejemplo, redefinir el método Fixnum#+:class Fixnum # Puedes, pero por favor no lo hagas def +( otro ) self - otro endendNo necesitas eloperator+ de C++, etc.Incluso puedes tener acceso estilo array si defines los métodos [] y[]=. Para definir los métodos unarios + y – (piensa en +1 y -2),debes definir los métodos +@ and -@ respectivamente.Sin embargo, los siguientes operadores no son simplificacionessintácticas. No son métodos, y no pueden ser redefinidos:=, .., ..., !, not, &&, and, ||, or, !=, !~, ::
    • Además, +=, *= etc. sólo son abreviaciones para var = var + otra_var, var= var * otra_var, etc. y por ende no pueden ser redefinidos.Para saber másCuando estés listo para saber más sobre Ruby, visita nuestra secciónde Documentación.Ruby es…Un lenguaje de programación dinámico y de código abierto enfocadoen la simplicidad y productividad. Su elegante sintaxis se sientenatural al leerla y fácil al escribirla.Leer más…# Output "I love Ruby"say = "I love Ruby"puts say# Output "I *LOVE* RUBY"say[love] = "*love*"puts say.upcase# Output "I *love* Ruby"# five times5.times { puts say }