Author Archives: Uriel

About Uriel

Programador en constante aprendizaje, futuro ing. en Desarrollo de Software. "La escuela es para socializar, internet es para aprender" Viviendo en la era javaScript.

Hashes en Ruby.

Un diccionario es muy parecido a un arreglo, con la diferencia más clara es que tú defines en qué posición se guarda el arreglo. Una aproximación clara de lo que es un hash se da con los diccionarios (por eso puedes llamarlo de las 2 maneras), cuando buscas algo en un diccionario no lo haces a través de números, ni el diccionario está ordenado de manera aleatoria, existe una relación entre el contenido y la posición en la que está guardado.

Si lo anterior no te queda aún muy claro veamos cómo definir un hash:

lenguajes = Hash.new
lenguajes["ruby"] = "Creado por Matz"
lenguajes["python"] = "No puntos y coma ni llaves"
lenguajes["java"] =" Lenguaje compilado"

Considero que el ejemplo anterior es bastante explícito, es una de las formas de declarar un hash, como instancia de la clase Hash. Vemos cómo asignamos una cadena a un index, cada index es el nombre de un lenguaje y el valor es una característica del lenguaje, si quisiéramos saber algo sobre JAVA, haríamos:

puts lenguajes["java"]

Mucho más claro y sencillo, además de más rápido que un arreglo, ahora bien, veamos una forma más de declarar un Hash:

lenguajes = {'ruby' => 'Creado por Matz', 'python' => 'Lenguaje interpretado'}

Como puedes ver el index, va seguido del operador => que signa el valor. Al ser igual al ejemplo anterior considero que no hay mucha dificultad para relacionar ambos ejemplos.

Ahora bien, eso es lo que por ahora necesitas saber sobre los Hashes, sin embargo hay algo muy interesante en Ruby que se conoce como símbolos, los símbolos son los objetos más sencillos, sólo tienen un nombre y un id, éste id los identifica, no pueden haber dos símbolos del mismo nombre, ésto es muy interesante porque tú por ejemplo puedes tener dos cadenas así:

"Hola mundo"
"Hola mundo"

Pero no dos símbolos así:

:hola_mundo
:hola_mundo

En el primer ejemplo, ambas cadenas son distintas, en el segundo amos símbolos son el mismo. Esto es útil con los hashes porque aumenta la velocidad de los mismos, puesto que Ruby no tiene que estarlos declarando constantemente, con una vez basta, veamos cómo usar símbolos con hashes:

lenguajes = Hash.new
lenguajes[:ruby] = "Creado por Matz"
lenguajes[:python] = "No puntos y coma ni llaves"
lenguajes[:java] =" Lenguaje compilado"

Muy sencillo, nota como cada símbolo se identifica porque su nombre inicia con :.

Con esto terminamos lo que corresponde a hashes, seguramente los usaremos más adelante, así que haz varias pruebas con ellos, de ahora en adelante nos adentraremos en la programación orientada a objetos con Ruby.

Operaciones usando arreglos con Ruby

Los arreglos tienen utilidad en muchísimas aplicaciones, en el artículo anterior vimos cómo definirlos en Ruby, y en éste veremos algunas operaciones básicas utilizando arreglas, todas éstas provenientes del Kernel de Ruby.

La primera operación que querrás ejecutar sobre un arreglo, seguramente será la de recorrerlo, es decir, ir a través de todos sus elementos, ya sea para usarlos o para buscar algún elemento.

Mi ciclo de recorrido favorito en Ruby, es el que se ejecuta a través del método each, éste método pertenece a la clase Array en Ruby, lo que significa que todos los arreglos lo tienen. Cabe mencionar que hay varias formas de recorrer arreglos en Ruby además de las que veremos (un par), luego de haber dicho ésto veamos el ejemplo:

lenguajes = ["Ruby","Python","JAVA","javaScript"]
lenguajes.each do |lenguaje|
  puts lenguaje
end

Lo que me gusta acerca de each es lo claro de la sintaxis, es decir, a simple vista puedes ver cómo funciona el método. Si aún hay cosas que no te quedan claras, te explico. El método each se aplica sobre el arreglo, en el ejemplo, nuestro arreglo es lenguajes, y se manda un bloque (ojo con esto), este bloque itera cada elemento dentro del arreglo y lo almacena sobre la variable lenguaje, es decir, en cada iteración, el elemento actual está en lenguaje, por eso si ejecutas lo anterior verás como con puts, imprimimos cada cadena del arreglo.

Lo anterior, fue algo bastante del estilo Ruby, si quieres algo más convencional podrías recorrer el arreglo con un ciclo for in, veamos el ejemplo:

for i in lenguajes
  puts i
end

Como ves, esto es algo más parecido a lenguajes comunes como JAVA, i es la variable que toma el valor dentro del arreglo, que en este ejemplo retomamos el anterior arreglo lenguajes. Sencillo ¿no?

Veamos ahora algo un poco más complicado. Lo que veremos es el método map, que también es parte de la clase Array. Map, itera cada uno de los elementos, le aplica las modificaciones que tú definas en un bloque, y retorna un nuevo arreglo con las modificaciones, aquí el ejemplo:

lenguajes = ["python","ruby","java"] #todos minusculas
nuevoArreglo = lenguajes.map{|lenguaje| lenguaje.capitalize}
nuevoArreglo.each do |l|
   puts l
end

Te invito a que pruebes el anterior ejemplo en tu instalación de Ruby, lo que verás es cómo cada uno de los elementos en lenguaje se pasan a nuevoArreglo, pero con la primera letra en mayúsucula (por el método capitalize), como verás, map también se ejecuta con un bloque, ésta vez delimitado por {}, adentro definimos una variable para almacenar cada iteración del arreglo, llamada lenguaje, y luego modificamos la variable, en éste ejemplo colocamos la primera letra en mayúscula, genial ¿no?

Lo anterior puede que haya sido un poco complejo si estás iniciando a programar, no te preocupes si no te quedó del todo claro, te aseguro que en el momento en que requieras una operación como la anterior, podrás venir aquí y todo quedará más claro.

Existen muchísimas otras operaciones que se pueden ejecutar con arreglos, por ejemplo ordenarlo:

calificaciones = [10,8,6,9]
calificaciones.sort

Obtener el tamaño del arreglo:

calificaciones.size()

Y así podríamos seguir mencionando otros, pero para no complicar más el curso básico, lo dejaremos ahí por ahora.

Bien, por ahora dejaremos los arreglos para que en el siguiente artículo pasemos a ver los Hashes o Diccionarios.

Arreglos en Ruby

Los arreglos, son estructuras que almacenan elementos de diferentes tipos, o al menos así son en Ruby, también puedes almacenar elementos de un solo tipo.

Los arreglos sirven para poder estructurar información y acceder a ella a través de un index, éste index es la posición que los elementos tienen dentro del arreglo, siendo el primero 0.

Para no confundirnos tanto con pura teoría, veamos cómo crear un arreglo en Ruby, es muy sencillo:

nombres = []

Como ves, un arreglo se define utilizando [] como delimitadores de lo que contiene el arreglo, también puedes hacerlo como instancia de la clase Array:

nombres = Array.new

Ahora bien, si queremos iniciar el arreglo con ciertos valores adentro, es tan sencillo como lo siguiente:

lenguajes = ["Ruby", "Python", "PHP", "C", "JAVA"]

El arreglo anterior tiene 5 elementos y como te mencionaba antes, es posible acceder a cada uno de ellos utilizando su posición, es muy importante que recuerdes que en los arreglos la posición inicial es la 0. Veamoslo en un ejemplo:

lenguajes = ["Ruby", "Python", "PHP", "C", "JAVA"]
puts "Estamos aprendiendo a programar arreglos en #{lenguajes[0]}"

 

Lo anterior, imprimirá que estamos aprendiendo arreglos en Ruby, puesto que accedimos a la posición 0 del arreglo que almacena la cadena Ruby.

Como dije al principio, los arreglos pueden almacenar estructuras u objetos de cualquier tipo, incluso otros arreglos:

ejemplo = ["Hola",1.1,2,[5,":D"]]

Lo anterior es válido en Ruby, hasta ahora todo ha sido común así que salgamos un poco de lo cotidiano y veamos algo más al estilo Ruby, lo que te mostraré a continuación se trata del método %w y nos ayuda a crear arreglos de cadenas, de una manera más sencilla para nosotros los programadores:

lenguajes = %w{Ruby Python JAVA C PHP}

Sin comillas y sin comas, genial ¿no? Como te mencionaba, el método anterior sólo sirve para crear arreglos de cadenas.

Lo anterior ha sido bastante útil, con ésto concluiremos éste artículo. Sin embargo, en el siguiente veremos operaciones con arreglos que harán lo aprendido aquí muchísimo más interesante.

Salida y entrada de datos en consola con Ruby

El kernel de Ruby carga consigo una buena cantidad de métodos entrada salida, conocidos también como métodos I/O (por Input/Output), entre ellos tenemos gets, put, print, printf, putc y algunos otros que están más relacionados con el manejo de archivos, tópico que veremos más adelante en el curso.

En este artículo veremos algunos de ellos, cabe mencionar que éstos métodos, como su nombre lo indica, sirven para recibir o imprimir datos a través de la consola para interactuar con el usuario.

El más sencillo tiene que ser print, de hecho print es una impresión sencilla, si ejecutas el siguiente programa en tu consola, deberás ver el mensaje en ella:

print "Hola mundo"

Si ejecutaras dos veces la anterior instrucción, notarías que el texto sale pegado, a menos que dentro de las mismas cadenas coloque espacios. En realidad la mayoría de las veces requerimos de que cada impresión de pantalla salga en una línea diferente de la consola, y eso es precisamente lo que hace puts.

puts "Hola"
puts "mundo"

Ahora bien, si ejecutas el programa anterior, verás cada impresión en una línea de la consola diferente.

Para terminar con las impresiones de pantalla, veamos algo con lo que los programadores en C, se sentirán más cómodos, se llama printf y funciona así:

name = "Uriel"
edad = 18
printf "Me llamo %-10s y tengo %3d", name, edad

El ejemplo anterior imprimirá mi nombre con máximo 10 caracteres y mi edad en máximo 3 dígitos, %d es para enteros, %s para cadenas y %f para flotantes.

Ahora bien veamos como aceptar datos del usuario desde la consola:

nombre = gets

Creo que no podría ser más sencillo, el método gets es el que nos permite recibir información del usuario, gets, siempre recibe una cadena y termina de recopilar la información cuando existe un salto de línea. El problema con gets es que devuelve una cadena que si ingreso mi nombre se vería así “Uriel \n” lo cual no es del todo bueno, pero tiene solución y es a través del método chomp.

nombre = gets.chomp

Después de chomp, mi nombre regresaría algo así “Uriel”.

Por último, me parece un excelente momento para que probemos un programa más concreto, creemos uno que nos salude:

print "Dime tu nombre: "
nombre = gets.chomp
puts "Hola #{nombre}, un gusto conocerte"

Del código anterior, lo único que no hemos visto es el operador #{} y me parece un excelente momento para explicarlo, leyendo el código podrás notar que es el operador de concatenación en Ruby, así pues, cuando necesites combinar el valor de una variable con una cadena, deberás colocar la variable dentro de las llaves del operador anterior.

Bien, con eso quedamos con los métodos de entrada salida y pasaremos en el siguiente artículo a estudiar los arreglos en Ruby.