Conociendo Ruby

Ruby es un lenguaje de programación orientado a objetos cuya popularidad está creciendo a pasos agigantados, varios estudios lo definen como uno de los lenguajes de programación más populares en el 2014, y uno de los mejores pagados. Por ende el propósito de este artículo es darte una breve pero concisa introducción a Ruby, empecemos!

Ruby, ruby y RUBY?

Ruby es un lenguaje de programación dinámico enfocado a la simplicidad y productividad, creado por Yukihiro “Matz” Matsumuto. ruby (la versión en minúsculas) es el interprete de Ruby, el se encarga de leer los programas y ejecutar las diferentes instrucciones. Luego esta RUBY, o más bien no está, Ruby no es un acrónimo y por lo tanto no es correcto escribirlo en mayúsculas, los desarrolladores también hacen esto (igual de manera incorrecta) con Perl, tal vez porque estén acostumbrados a ver lenguajes de programación como COBOL y BASIC, pero en el caso de Ruby no es así, es Ruby para el lenguaje y ruby para el interprete.

Instalando Ruby

Existen dos formas principales de instalar Ruby:

  1. Compilar desde código fuente: Esta opción es para aquellos que le gusta configurar las variables de su entorno, y se sienten lo suficientemente cómodos y confiados sobre el uso de su plataforma
  2. Herramientas de terceros: Esta es la opción más común de instalación y es la que utilizaremos en este artículo a través de RVM (Ruby Version Manager), pues no solo hace que instalar Ruby sea lo suficientemente fácil, también permite administrar múltiples copias de Ruby en tu computadora, por ejemplo si un proyecto lo quieres hacer con Ruby 1.8.7 y otro proyecto lo quieres hacer con Ruby 1.9.2.

Para instalar RVM en tu máquina junto con la última versión de Ruby, entra a tu terminal y ejecuta el siguiente comando:

$ \curl -L https://get.rvm.io | bash -s stable --ruby

Y eso es todo! Al finalizar la instalación ejecuta en tu terminal ruby -v para visualizar la versión de Ruby que tienes. RVM solo está disponible para MAC OS X y Linux o cualquier otro sistema operativo basado en UNIX, los usuarios Windows pueden usar pik (que es como el RVM solo que para Windows) o bien pueden usar el típico RubyInstaller.

Kit de sintaxis básica

Ahora que tenemos Ruby propiamente instalado, podemos empezar a analizar su sintaxis, la siguiente tabla resume los comandos básicos de Ruby, no tienes que memorizarlos (Ruby es bastante intuitivo) pero leerlas te puede dar una idea de como es la sintaxis de Ruby.

Operación Ejemplos Comentarios
Aritmética 2 + 3
2 – 3
2 * 3
2 / 3
10.3 + 20.25
103 – 202.5
32.9 * 10
100.0 / 0.23
Todas las operaciones aritméticas pueden trabajar sobre números enteros o números decimales. Mezclar enteros con decimales producen resultados decimales.
Asignación x = 1
saludo = “Hola”
Esta operación asigna una variable local (la de la izquierda) a un objeto (el de la derecha). Por ahora puedes pensar en un objeto como un valor representado por una variable.
Comparar dos valores x == y Observa que en este caso son dos signos de “=“, no solamente uno.
Convertir un string a un número y viceversa x = “100”
s = x.to_i
x = s.to_s
En este caso se convirtió un string (“100”) a un número (x.to_i) y después se regreso a un string (s.to_s)
Imprimir algo en la pantalla print “Hola”
puts “Hola”
x = “Hola”
puts x
x = “Hola”
print x
puts añade una nueva línea al final del string (si éste no la tiene), print no añade ninguna línea, simplemente deja el curso al final de la misma. 
Condicionantes if x == y
puts “Si!”
else
puts “No”
end
Las condiciones siempre terminan con la palabra reservada end
Objetos booleanos y nulos true
false
nil
Los objetos true y false normalmente fungen como valores de retorno para expresiones condicionales.El objeto nil es como un “sin objeto”, pues indica la ausencia de valor o resultado. false y nil causan que una condicionante falle, mientras que el resto de los objetos como 0, cadenas vacías, y true (obviamente) causan que sea exitosa. 
Objeto por default self La palabra reservada self se refiere al objeto por default que está ejecutando la acción.
Comentarios # A
x + 1 # A
Los comentarios son ignorados por el interprete. 

Nomenclatura de Ruby

Ruby 4 identificadores principales y cada uno de ellos sigue sus propias reglas para la nomenclatura:

  1. Variables
    • Locales: Empiezan con una letra en minúscula o un guión bajo seguido de un conjunto de letras o números: x, string, abc, start_value, firstName son nombres válidos para variables locales. La convención de Ruby es utilizar guiones bajos en lugar de Camel case, por ejemplo first_name en lugar de firstName.
    • Instancia: Siguen la misma nomenclatura que las variables locales, solo que siempre empiezan con el símbolo de @. Por ejemplo @age, @last_name
    • Clases: Siguen las mismas reglas que las variables de instancia, excepto que empiezan por dos @, por ejemplo: @@total
    • Globales: Éstas son reconocidas porque empiezan con un símbolo de $, por ejemplo $population. Son las únicas variables que no siguen una nomenclatura como tal pues hay diferentes variables como $1, $:, $/, $LOAD_PATH. Siempre y cuando inicie con un signo de $ es una variable global.
  2. Constantes: Inician con una letra mayúscula: A, String, FirstName y STDIN son todas nombres de constantes válidas. La convención de Ruby es usar Camel case (FirstName) o todo en mayúsculas separado por guiones (FIRST_NAME)
  3. Palabras reservadas: Ruby tiene varias palabras reservadas, pues estas palabras están asociadas a tareas y contextos específicos de Ruby por ejemplo: def (para definir un método), class (para definición de clase), if (para condiciones), etc.
  4. Métodos: Los nombres de métodos de Ruby siguen las mismas reglas y convenciones que las variables locales, excepto que pueden terminar en ?, ! o =. Y esto es algo típico de Ruby pues al seguir la misma nomenclatura que las variables locales no quieren llamar la atención sino más bien mezclarse en el contexto del programa. En algunos programas realmente no puedes discernir si estás viendo una variable o un método, y eso es intencional.
Ejemplos de variable para cada uno de sus tipos
Tipo Correcto Incorrecto
Local first_name firstName, _firstName_, __firstName, name1
Instancia @first_name @First_name, @firstName, @name1
Clase @@first_name @@First_name, @@firstName, @@name1
Global $FIRST_NAME ———-

Escribiendo un programa en Ruby

Usando un editor de texto escribe el siguiente código y guárdalo bajo el nombre de celsius_to_fahrenheit.rb

celsius = 100
fahrenheit = (celsius * 9 / 5) + 32
print "The result is: "
print fahrenheit
puts “."

Antes de ejecutar el programa es buena idea checar la sintaxis para verificar que no hayamos cometido errores:

$ ruby -cw celsius_to_fahrenheit.rb

Este comando leerá el programa (sin ejecutarlo) para verificar la sintaxis, el “-cw” es una bandera que indica lo siguiente “c” significa “check for syntax errors” y “w” activa un nivel inteligente de alertas, es decir ruby (el interprete) te lanzará una alerta si tu código tiene una semántica cuestionable, aunque su sintaxis esté bien. Asumiendo que escribiste bien el programa, deberías ver algo como lo siguiente:

$ Syntax OK

Para ejecutar el programa propiamente, escribe el siguiente comando:

$ ruby celsius_to_fahrenheit.rb

Si todo salió bien, deberías ver la siguiente salida:

The result is 212.

Refactorizando

El programa anterior está bien, pero obviamente se podría mejorar. Un programa que te dice una y otra vez que el resultado es 212 es bastante limitado. Sería mejor que le preguntara al usuario la cantidad a convertir, y así hacerlo más dinámico. Ruby cuenta con muchas técnicas para leer datos durante la ejecución de un programa, una de ellas es get:

print "Hello. Please enter a Celsius value: "
celsius = gets
fahrenheit = (celsius.to_i * 9 / 5) + 32
print "The Fahrenheit equivalent is "
print fahrenheit
puts “."

Observa como en la segunda línea (celsius = gets) estamos obteniendo el valor durante la ejecución del programa, y después en la tercera línea lo transformamos a entero (a través de .to_i) para poder hacer la operación aritmética. Las líneas que imprimen se podrían convertir en una sola línea.

print "Hello. Please enter a Celsius value: "
celsius = gets
fahrenheit = (celsius.to_i * 9 / 5) + 32
print "The Fahrenheit equivalent is ", fahrenheit, “.\n"

Ejecutando el programa obtendremos ahora resultados dinámicos:

$ ruby celsius_to_fahrenheit.rb
Hello. Please enter a Celsius value: 20
The Fahrenheit equivalent is 68.
$ ruby celsius_to_fahrenheit.rb
Hello. Please enter a Celsius value: 40
The Fahrenheit equivalent is 104.

Refactorizando aún más!

Si consolidamos todas las operaciones del programa (leer la entrada, hacer la operación aritmética e imprimir el resultado) el programa se puede refactorizar aún más:

print "Hello. Please enter a Celsius value: "
print "The Fahrenheit equivalent is ", gets.to_i * 9 / 5 + 32, ".\n"

Esta versión economiza las variables (si te fijas no hay ninguna!), y obtiene como resultado un programa corto de dos líneas pero un tanto críptico, por decir un programador novato no lo va a entender a la primera. Existen muchos escenarios en donde los programadores deben decidir entre programas largos pero más claros a programas cortos pero “oscuros”, todo es parte de como sea tu estilo como programador y de que sea mejor para el contexto que estás programando.

Esperamos que artículo te haya dado una base acerca del potencial de Ruby, por acá te dejamos un link de un curso gratuito que no te tomará más de 15 minutos completar.

xyz_smap:
1