Overblog Seguir este blog
Edit post Administration Create my blog
5 febrero 2014 3 05 /02 /febrero /2014 00:27

Este tema es muy pero muy importante, ya que nos permite tener practicamente una base de datos accesible de manera dinámica organizado en pares, para entenderlo voy a dar una definición pequeña:

 

Un hash es un grupo de valores donde se organizan por pares, donde existen los llamados llaves o "keys" y los valores respectivos asociados a esos "Keys", la sintaxis es la siguiente:

 

{llave1 => valor1, llave2 => valor2, llave3 => valor3} 

 

Las llaves pueden ser un simbolo, un numero, una letra o algun objeto compatible, los valores pueden ser un arreglo, otro hash, letras, numeros, booleans o cualquier objeto compatible, siempre deben estar en los signos de llaves " { " y " } " y el asignador es el operador =>, que genera un "par", ahora los pares deben estar separados por comas ","

 

Asignaciones

 

Un ejemplo:

 

irb(main):134:0> {1=>"as",2=>"bb"}

=> {1=>"as", 2=>"bb"}

 

Aquí le estamos diciendo que la llave 1 tiene el valor "as" y que la llave 2 tiene el valor "bb"

 

irb(main):139:0> mi_hash = {:edad => 2, :tipo => "perro"}

=> {:edad=>2, :tipo=>"perro"}

irb(main):140:0> mi_hash = {edad: 2, tipo: 'perro'}

=> {:edad=>2, :tipo=>"perro"}

 

En este ejemplo estamos diciendo que la llave :edad (del tipo simbolo) tiene el valor 2 y que la llave :tipo tiene el valor "perro", en la siguiente linea 140, estamos asignando las mismas llaves y valores, pero la sintaxis esta un poco mas resumida, el par ahora esta compuesto por los 2 puntos seguidos edad: y luego un espacio y seguido del valor 2 quedando "edad: 2", el unico inconveniente es que la llave siempre va a ser un simbolo y si encuentra alguna llave que no puede hacer la conversion va a darnos un error.

 

Tambien es posible combinar las sintaxis según la conveniencia:

 

irb(main):159:0> {s: "as",c: "bb", 2 => "cc"}

=> {:s=>"as", :c=>"bb", 2=>"cc"}

 

Como podemos observar, los 2 primeros pares tienen la sintaxis resumida y estan convirtiendo en string a la llave s y a la llave c, pero en el ultimo par, se usa la sintaxis tradicional y se tiene la llave 2 del tipo numero asignando el valor "cc" del tipo string o palabra o cadena de texto como quieran llamarle.

 

Consultando valores y pares

 

Podemos realizar consultas diversas consultas por ejemplo:

 

irb(main):160:0> mi_hash

=> {:edad=>2, :tipo=>"perro"}

irb(main):161:0> mi_hash.keys

=> [:edad, :tipo]

irb(main):162:0> mi_hash.values

=> [2, "perro"]

irb(main):163:0> mi_hash.first

=> [:edad, 2]

 

En la línea 161 estamos preguntando por medio del método keys, que nos indique cuantas "llaves" tiene el hash, y nos devuelve un arreglo que indica que tenemos 2 llaves (:edad y :tipo), luego en la línea 162 estamos preguntando los valores que tiene el hash, que tambien nos devuelve un arreglo, luego en el 163 le estamos indicando que nos devuelva el primer "par" y lo hace dándonos un arreglo.

 

Podemos consultar directamente por la llave, lo cual hace una verdadera búsqueda de base de datos

 

irb(main):165:0> mi_hash[:edad]

=> 2

irb(main):166:0> mi_hash[:tipo]

=> "perro"

 

Aquí nos devuelve directamente el valor que solicitamos en vase a la llave, y es aquí la utilidad real de un hash, la consulta se hace colocando la llave entre corchetes " [ " y " ] ".

 

Para poder saber que llave contiene un determinado valor, se puede utilizar el método key de la siguiente manera:

 

irb(main):169:0> mi_hash.key 2

=> :edad

irb(main):173:0> mi_hash.key "perro"

=> :tipo

 

En ambos casos, tanto la búsqueda por la llave como por el valor, si no lo encuentra, devolverá un nil

 

Otra forma de hacer lo mismo es poder invertir y realizar la busqueda

 

irb(main):186:0> mi_hash

=> {:edad=>2, :tipo=>"perro"}

irb(main):187:0> mi_hash.invert

=> {2=>:edad, "perro"=>:tipo}

irb(main):188:0> mi_hash.invert[2]

=> :edad

 

Utilizando el método invert, cambia cada llave por el valor y luego podemos hacer la consulta como si se tratara de una llave pero hay que tener cuidado con los valores que sean iguales en otras llaves, ya que al invertirlo solo tomará el primero de los pares que tengan ese valor por ejemplo:

 

irb(main):023:0> r= {j: 2,k: 2}

=> {:j=>2, :k=>2}

irb(main):024:0> r.invert

=> {2=>:k}

 

Se puede ver que solamente queda el ultimo par al momento de invertir el hash.

 

Como un hash puede contener otros hash, una forma sencilla de obtener el ultimo elemento es convertir el hash en arreglo y luego obtener el ultimo elemento del arreglo que seria el ultimo par del hash.

 

irb(main):196:0> mi_hash.to_a

=> [[:edad, 2], [:tipo, "perro"]]

irb(main):197:0> mi_hash.to_a.last

=> [:tipo, "perro"]

 

Hay que considerar que un hash puede almacenar otros hash y arreglos, con lo cual se puede volver trivial obtener el ultimo valor, por lo que Ruby no coloca el método last y nos obliga a realizar una lógica para obtener nuestro último valor segun nuestra necesidad.

 

Agregando pares

 

Podemos agregar más pares de manera sencilla, por ejemplo:

 

irb(main):200:0> mi_hash.store :color, :caramelo

=> :caramelo

irb(main):201:0> mi_hash

=> {:edad=>2, :tipo=>"perro", :color=>:caramelo}

 

Usando el método store, podemos almacenar un nuevo par, otra forma tambien es con:

 

irb(main):203:0> mi_hash

=> {:edad=>2, :tipo=>"perro", :color=>:caramelo}

irb(main):204:0> mi_hash[:habilidad] = 'ladrar mucho'

=> "ladrar mucho"

irb(main):205:0> mi_hash[:ventajas] = [:alto,:fuerte,:entrenado]

=> [:alto, :fuerte, :entrenado]

irb(main):206:0> mi_hash

=> {:edad=>2, :tipo=>"perro", :color=>:caramelo, :habilidad=>"ladrar mucho", :ventajas=>[:alto, :fuerte, :entrenado]}

 

En la línea 204 ponemos el valor de la llave entre corchetes y luego con el operador = asignamos el valor de la nueva llave, en la línea 205 estamos agregando un par donde el valor es un arreglo.

 

Tambien es posible agregar mas valores de una sola vez, usando lo siguiente:

 

irb(main):203:0> mi_hash

=> {:edad=>2, :tipo=>"perro", :color=>:caramelo}

irb(main):210:0> mi_hash = mi_hash.merge({ :nombre => :fido, :entrenado => true })

=> {:edad=>2, :tipo=>"perro", :color=>:caramelo, :nombre=>:fido, :entrenado=>true}

irb(main):211:0> mi_hash = mi_hash.merge nombre: :fido, entrenado: true

=> {:edad=>2, :tipo=>"perro", :color=>:caramelo, :nombre=>:fido, :entrenado=>true}

 

En este ejemplo se puede observar que hemos utilizado el método merge donde le asignamos un hash y mezcla en nuestro hash, tambien se ha de observar que en la linea 211 es lo mismo solo que se ha eliminado los paréntesis, los símbolos de llaves y se utiliza la sintaxis corta, ayudando todo esto a tener una visibilidad mucho más simple.

 

Eliminado pares

 

Para eliminar pares es muy sencillo, para ello podemos usar el método delete

 

irb(main):219:0> mi_hash

=> {:edad=>2, :tipo=>"perro", :color=>:caramelo, :nombre=>:fido, :entrenado=>true}

irb(main):220:0> mi_hash.delete :entrenado

=> true

irb(main):221:0> mi_hash

=> {:edad=>2, :tipo=>"perro", :color=>:caramelo, :nombre=>:fido}

 

Aquí hemos borrado por la llave :entrenado, ahora si queremos eliminar por el valor podemos usar:

 

irb(main):237:0> mi_hash

=> {:edad=>2, :tipo=>"perro", :color=>:caramelo, :nombre=>:fido}

irb(main):238:0> mi_hash.delete mi_hash.invert.delete 2

=> 2

irb(main):239:0> mi_hash

=> {:tipo=>"perro", :color=>:caramelo, :nombre=>:fido}

 

Donde en la línea 238 primero invertimos el hash, luego obtenemos la llave del valor 2 con el método delete (que tambien se pudo utilizar otro método que nos retorne la llave) acto seguido como ya tenemos la llave, el método delete del hash sin invertir eliminará el par.

 

Actualizando valores de los pares

 

Para actualizar se puede usar simplemente los métodos store y merge, también llamando la llave por medió de los corchetes, para actualizar las llaves se puede usar el invert pero hay que tener cuidado con los valores duplicados.

 

irb(main):244:0> mi_hash

=> {:tipo=>"perro", :color=>:caramelo, :nombre=>:fido}

irb(main):245:0> mi_hash.store :nombre, :canuto

=> :canuto

irb(main):246:0> mi_hash

=> {:tipo=>"perro", :color=>:caramelo, :nombre=>:canuto}

irb(main):247:0> mi_hash = mi_hash.merge nombre: :canito

=> {:tipo=>"perro", :color=>:caramelo, :nombre=>:canito}

irb(main):248:0> mi_hash[:nombre]=:tobi

=> :tobi

irb(main):249:0> mi_hash

=> {:tipo=>"perro", :color=>:caramelo, :nombre=>:tobi}

 

De la misma forma parecida a la que se agregaban pares y valores, para actualizarlos simplemente se reutiliza la llave o las llaves o pares que se desea actualizar, dando bastante flexibilidad.

 

Bueno hemos avanzado con este importante capitulo 15 y seguiremos con el capitulo 16, por favor dudas y comentarios pueden hacerlo si ningún tipo de restriccion, si desean agradecer también, gracias y comenten.

 

Compartir este post

Repost 0
Published by Daniel A. Nuñez C. - en Tutorial Ruby
Comenta este artículo

Comentarios

Presentación

  • : El blog de Daniel A. Nuñez C.
  • El blog de Daniel A. Nuñez C.
  • : Un blog sobre tecnologías y futuro, también sobre lenguaje de programación Ruby y más.
  • Contacto

Perfil

  • Daniel A. Nuñez C.
  • Ingeniero de Sistemas
  • Ingeniero de Sistemas

Donaciones/Donations

Por favor considera realizar una donación

Please make a donation

btn_donateCC_LG.png

Buscar Tema En Este Blog

Archivos