Guía de inicio en Ruby. Instalación y comandos básicos


Ruby es un lenguaje de programación de alto nivel, disponible para Windows, Linux y Mac. Diseñado con el objetivo de ser productivo y divertido. Con él puedes crear aplicaciones Web, un cliente de correos personal, APIs, todo depende de tus habilidades e imaginación.

Conceptos como funciones anónimas, clases abiertas o metaprogramación los verás en acción en los programas que construyas.

¿Dónde se usa Ruby?

Puedes encontrar código ruby en Google SketchUp, GitHub, Twitter, Toronto Rehab, MORPHA y frameworks de desarrollo web como Sinatra y Ruby on Rails.

Hay otros ejemplos, pero con estos puedes hacerte una idea de su alcance.

Cómo instalarlo

La forma puede variar en dependencia del sistema operativo y necesidades del usuario, por lo cual me centraré en GNU/Linux Debian y derivados como sistema operativo para la instalación.

Abre una consola y ejecuta el comando $ sudo apt-get install ruby-full. Si usas otro tipo de sistema operativo, puedes encontrar información de cómo instalarlo en el sitio oficial.

En lo adelante, cada vez que un comando necesite ejecutarse como súper usuario, lo mostraré con el símbolo de número (#) para evitar escribir la palabra sudo. Lo contrario se especificará con el símbolo $.

Conociendo el intérprete

Los comandos que utilizarás para trabajar con el intérprete de Ruby serán irb e ir. A continuación plasmaré algunas preguntas retóricas para que conozcas cómo usarlos.

¿A qué clase pertenecen los objetos 1, 1.5, true, false, "texto"?

Para responder esta interrogante entraré en la consola interactiva del lenguaje:

$ irb

Dentro del intérprete puedo preguntar los tipos de datos de los valores anteriores:

irb(main):001:0> 1.class 
=> Fixnum 
irb(main):002:0> 1.5.class 
=> Float 
irb(main):003:0> true.class 
=> TrueClass 
irb(main):004:0> false.class 
=> FalseClass 
irb(main):005:0> "texto".class 
=> String 
irb(main):006:0>

Observa que todo es un objeto, incluso lo que en otros lenguajes serían tipos de datos primitivos. Para conocer de qué clase proviene un objeto, se le preguntó directamente a través del método class.

Es normal que los objetos tengan métodos, por lo que la siguiente interrogante será:

¿Cómo conocer los métodos de un objeto?

Ve a la consola interactiva y ejecuta "texto".methods, verás la siguiente salida:

=> [:<=>, :==, :===, :eql?, :hash, :casecmp, :+, :*, :%, :[], :[]=, :insert, :length, :size, :bytesize, :empty?, :=~, :match, :succ, :succ!, :next, :next!, :upto, :index, :rindex, :replace, :clear, :chr, :getbyte, :setbyte, :byteslice, :scrub, :scrub!, :freeze, :to_i, :to_f, :to_s, :to_str, :inspect, :dump, :upcase, :downcase, :capitalize, :swapcase, :upcase!, :downcase!, :capitalize!, :swapcase!, :hex, :oct, :split, :lines, :bytes, :chars, :codepoints, :reverse, :reverse!, :concat, :<<, :prepend, :crypt, :intern, :to_sym, :ord, :include?, :start_with?, :end_with?, :scan, :ljust, :rjust, :center, :sub, :gsub, :chop, :chomp, :strip, :lstrip, :rstrip, :sub!, :gsub!, :chop!, :chomp!, :strip!, :lstrip!, :rstrip!, :tr, :tr_s, :delete, :squeeze, :count, :tr!, :tr_s!, :delete!, :squeeze!, :each_line, :each_byte, :each_char, :each_codepoint, :sum, :slice, :slice!, :partition, :rpartition, :encoding, :force_encoding, :b, :valid_encoding?, :ascii_only?, :unpack, :encode, :encode!, :to_r, :to_c, :>, :>=, :<, :<=, :between?, :nil?, :!~, :class, :singleton_class, :clone, :dup, :taint, :tainted?, :untaint, :untrust, :untrusted?, :trust, :frozen?, :methods, :singleton_methods, :protected_methods, :private_methods, :public_methods, :instance_variables, :instance_variable_get, :instance_variable_set, :instance_variable_defined?, :remove_instance_variable, :instance_of?, :kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :extend, :display, :method, :public_method, :singleton_method, :define_singleton_method, :object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exec, :__send__, :__id__]

El objeto contestó devolviendo todo su arsenal de funcionalidades y, lo único que se requiere para ello es llamar al método methods, sobre el objeto que quieras encuestar.

Con lo anterior sabes cuáles son los métodos del objeto, pero esto no es suficiente, es necesario conocer qué hacen. Toma como ejemplo el método upcase. Para conocer su descripción, abre un terminal y ejecuta (fuera del intérprete) $ ri String#upcase:

= String#upcase 

(from ruby core) 
------------------------------------------------------------------------------ 
  str.upcase   -> new_str 

------------------------------------------------------------------------------ 

Returns a copy of str with all lowercase letters replaced with their 
uppercase counterparts. The operation is locale insensitive---only characters 
``a'' to ``z'' are affected. Note: case replacement is effective only in ASCII 
region. 

Otra vez ruby responde, en inglés, aunque su creador es japonés. El método upcase devuelve una cadena de texto con todos los caracteres en mayúscula.

De está forma puedes conocer la función de los métodos de una instancia de una clase. Para conocer la función de un método de una clase ejecuta nombre_de_clase::metodo. Ejemplo:

$ ri String::new

= String::new 

(from ruby core) 
------------------------------------------------------------------------------ 
  String.new(str="")   -> new_str 

------------------------------------------------------------------------------ 

Returns a new string object containing a copy of str. 

Toda la documentación obtenida a través de ri viene de los comentarios dentro del código ruby. Este es uno de los puntos fuertes de este lenguaje: su documentación interna.

Conclusiones

Hasta aquí has aprendido a conocer las clases de la que se derivan los objetos, sus métodos y cómo obtener documentación sobre ellos. Además, interactuaste con los comandos irb y ri, herramientas básicas para probar pequeños fragmentos de código y obtener documentación cuando estés sin conexión.

En la próxima entrega crearás un script que interactúa con el usuario. Eso te dará la habilidad para manipular cadenas de texto, números y crear estructuras condicionales.

¿Qué crees de Ruby? ¿Has trabajado con él alguna vez? Te invito a unirte a los comentarios.