Introducción y primeros pasos con Ruby

¿Qué es Ruby?

Ruby, es un lenguaje de programación de alto nivel, interpretado, orientado a objetos (en Ruby prácticamente todo es un objeto) y de código abierto, enfocado en la simplicidad y productividad del programador, con una sintaxis sencilla que es fácil de leer y escribir. Fue creado por un programador Japonés, Yukihiro Matsumoto, comenzando su desarrollo en el año 1993, siendo liberada la primera versión al público en el año 1995, actualmente la última release estable es la 2.1.4, pueden ver más información aquí

¿Cómo instalar Ruby?

Con esta pequeña introducción, es hora de ponernos a trabajar. Si usted es usuario Mac OSX o de alguna distrubución GNU/Linux, ya cuentan con ruby es sus máquinas, para chequearlo, pueden abrir una terminal y teclear:

ruby -v/ruby --version

deberían ver algo como esto:

ruby 2.0.0p247 (2013-06-27 revision 41674) [x86_64-darwin13.4.0]

Si usted es usuario de Windows, puede descargar desde aquí el instalador.

ahora en nuestra terminal, tecleamos

irb

para los usuarios de Windows, pueden localizar

fxri

desde la sección de Ruby del menú inicio, hasta aquí, ya podemos ver nuestro querido intérprete interactivo de Ruby

irb(main):001:>

a continuación vamos a escribir el «Hola Mundo» más sencillo que hayan escrito jamás.

irb(main):001:> puts "Hola Mundo"
Hola Mundo
nil

En este punto se estarán preguntando que significa el «nil» que aparece después de nuestro «Hola Mundo». En Ruby, nil es equivalente a lo que en la mayoría de los lenguajes se llama NULL y es el valor de retorno del método puts, éste recibe como argumento el mensaje que queremos desplegar en pantalla y su valor de retorno es ‘nil’, en otras palabras: no retorna ningún valor. En Ruby, siempre es devuelto el valor del última expresión evaluada y no hace falta utilizar la palabra reservada return a no ser que sea estrictamente necesario.

Ahora que ya hemos escrito nuestro primer «programa» en Ruby, vamos a ver algunos elementos del lenguaje

Arreglos (arrays) en Ruby

Al igual que la gran mayoría de los lenguajes podemos almacenar información de forma temporal dentro de arreglos, para definirlos, basta con hacer lo siguiente:

irb(main):020: 
irb(main):022:0> new_array = [1,2,3,4,6,7,8,9,10]
=> [1, 2, 3, 4, 6, 7, 8, 9, 10]

Podemos crear también una arreglo a partir de un «Rango»:

irb(main):021:0> (1..10).to_a
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
irb(main):022:0> (1...10).to_a
=> [1, 2, 3, 4, 5, 6, 7, 8, 9]
irb(main):023:0> ('a'..'z').to_a
=> ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]

Existe una sutil, pero importante diferencia respecto a los «Rangos», cuando se utiliza 1..10, se incluye el último elemento, sin embargo cuando se define 1…10 (noten la diferencia: en el segundo ejemplo se usan 3 puntos en vez de 2), el último valor (en el ejemplo: 10) no se incluye.

Ahora si quisiéramos iterar y realizar ciertas operaciones sobre cada elemento del arreglo, Ruby nos provee una gran variedad de métodos, en esta ocasión vamos a ver sólo 2 .each y .map

irb(main):028:0> (1..10).to_a.each {|elemento| puts elemento**2 }
1
4
9
16
25
36
49
64
81
100
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
irb(main):030:0> (1..10).to_a.map {|elemento| elemento**2 }
=> [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

El método .each recibe como argumento un bloque (más adelante ahondaremos más en este tema) de código y lo ejecuta por cada elemento de nuestro arreglo, en el ejemplo anterior, imprimimos el cuadrado de cada uno de los números, el método .map, también itera sobre cada elemento del arreglo, pero a diferencia de .each, retorna un nuevo arreglo con el resultado, pueden ver más sobre los Arreglos y Rangos, directamente en la documentación oficial.

Tipos de Variables en Ruby

En Ruby encontramos 5 tipos de variables:
Variables locales: las cuales sólo son accesibles, dentro del scope en donde son definidas, pudiendo ser un método o un bloque.

# ejemplo
my_var = "Hola Mundo"

Variables globales: al igual que en otros lenguajes, las variables globales, son accesibles en cualquier lugar de nuestra aplicación, no es una muy buena práctica usarlas, sin embargo existen algunas pre-definidas, que nos pueden ser de gran utilidad, pueden encontrar más información aquí.

# ejemplo
$my_global_bar = "Estoy accesible en cualquier lugar :(" las variables globales comienzan con el caracter $

Variables constantes: En ruby las constantes son un tipo de variables especial, para definir una constante ésta debe comenzar con una letra mayúscula.

# alternativa 1
PI = 3.141592653589793
# alternativa 2
Pi = 3.141592653589793

Variables de Clase: este tipo de variables comienzan con @@, pertenecen a la clase y están accesibles para cada una de sus instancias.

class Persona
  @@class_variable = 10
end

Variables de Instancia: este tipo de variables pertenece al objeto y son accesibles por el objeto, hasta que éste deja de existir, son un tipo de variables muy utilizadas en Ruby on Rails, para comunicar al controlador con las vista. Ejemplo:

class Example

 def some_method
    @instance_var = "Hola soy una variable de instancia y vivo dentro de un objeto"
  end

end

object = Example.new
puts object.some_method # => Hola soy una variable de instancia y vivo dentro de un objeto

Hashes en Ruby

Un hash, es un objeto que nos permite almacenar un valor asociado a una clave.

irb(main):031:0> hash = {"foo" => "bar", "bar" => "foo"}
irb(main):032:0> hash['foo']
=> "bar"
irb(main):035:0> hash.fetch('foo')
=> "bar"

En el ejemplo anterior, observamos que podemos obtener el valor, de 2 formas distintas, la primera hash['key'] y la segunda hash.fetch('key'), la diferencia entre ambos métodos, es que la primera nos devuelve nil, en caso de que la clave no exista y la segunda arroja un error, como se puede observar en el siguiente ejemplo:

irb(main):036:0> hash['missing']
=> nil
irb(main):037:0> hash.fetch('missing')
KeyError: key not found: "missing"

Bloques de código en Ruby

Un bloque, es un trozo de código que nos permite encapsular una serie de instrucciones y pasarlas como argumento a un método, es unas de las herramientas más potentes de Ruby, pero a su vez una de las más difíciles de comprender, veamos como funcionan los bloques en el siguiente ejemplo:

def test
  puts "ejecutando código dentro del método test"
  yield
  puts "ejecutando nuevamente el código dentro del método test"
end

test { puts "ejecutando el código dentro del bloque que hemos pasado como argumento" }

# esto no muestra la siguiente salida
# ejecutando código dentro del método test
# ejecutando el código dentro del bloque que hemos pasado como argumento
# ejecutando nuevamente el código dentro del método test

Como observamos en el ejemplo anterior la palabra reservada yield, nos permite ejecutar el código dentro del bloque.
Métodos y Clases
Es hora de adentrarnos en la última parte de este pequeño tutorial donde veremos, como definir métodos y clases en Ruby. Una clase es un molde que nos permite construir objetos y las métodos son las acciones que puede realizar un objeto, basta de preámbulos, veamos un ejemplo:

class Example
  @@total_chars = 0

  def initialize(word)
    @word_chars  = word.length
    puts "La palabra #{word}, tiene #{@word_chars} caracteres"
    @@total_chars += @word_chars
  end

  def get_total_chars
    puts "el total de caracteres son #{@@total_chars}"
  end
end

example1 = Example.new('Hello Word')
example1.get_total_chars
example2 = Example.new("I Love Ruby")
example2.get_total_chars
example3 = Example.new("I <3 Ruby")
example3.get_total_chars

# esto nos entrega la siguiente salida
# La palabra Hello Word, tiene 10 caracteres
# el total de caracteres son 10
# La palabra I Love Ruby, tiene 11 caracteres
# el total de caracteres son 21
# La palabra I <3 Ruby, tiene 9 caracteres
# el total de caracteres son 30

Expliquemos que es lo que acabamos de hacer, primero hemos definido un clase Example con una variable de clase @@total_chars, para ir acumulando la cantidad de caracteres de cada una de las palabras con las que vamos construyendo nuestros objetos, existe también un método initialize, el cual es el constructor de la clase, que se ejecuta automáticamente cuando crea un objeto, creamos también un método llamado get_total_chars, el cual nos devuelve el valor de la variable @@total_chars, por último hemos creado tres objetos y por cada uno llamado al método get_total_chars.

Bueno, espero que hayan disfrutado este pequeño tutorial, que nos servirá para pavimentar el camino para adentrarnos en el maravilloso mundo de Ruby on Rails.

Regístrate hoy en Styde y obtén acceso a todo nuestro contenido.