Nivel inicial4 min de lectura · Publicado el

Hashes en Ruby: crear, consultar y recorrer

Hashes en Ruby: una cajonera con etiquetas; contactos[:alberto] abre el cajón :alberto, la clave, y dentro está 600000000, el valor. Por clave, no por posiciónrubentejera.com "600000000":alberto:dariocontactos[:alberto]clave: la etiquetavalor: lo de dentro
Cada cajón es una clave con su etiqueta, como :alberto, y lo que guarda dentro es el valor, "600000000". contactos[:alberto] abre ese cajón; si la etiqueta no existe, devuelve nil.

Un hash es una colección que guarda parejas de clave y valor. Funciona como una cajonera con etiquetas: buscas el cajón por su etiqueta (la clave) y dentro está lo que guarda (el valor), aquí un teléfono. No buscas «el cajón número 3», como harías en un array, sino «el de Alberto».

Crear un hash

La clave y el valor pueden ser de casi cualquier tipo: textos, números o símbolos.

contactos = {
  "Alberto" => "600000000",
  "Barreto" => "611111111",
  159       => "622222222"
}

contactos["Alberto"]  # => "600000000"
contactos[159]        # => "622222222"
contactos["Nadie"]    # => nil (la clave no existe)

Claves con símbolos

Lo más habitual en Ruby es usar símbolos como claves. Hay dos formas de escribirlos, y son equivalentes:

contactos = {
  :alberto => "600000000",  # forma clásica
  dario: "633333333"        # forma abreviada, la más usada
}

contactos[:alberto]  # => "600000000"
contactos[:dario]    # => "633333333"

Claves repetidas

Si repites una clave, gana el último valor y Ruby avisa con un warning (si ejecutas con ruby -w):

contactos = { "Alberto" => "600000000", "Alberto" => "633333333" }
# warning: key "Alberto" is duplicated and overwritten
contactos  # => {"Alberto" => "633333333"}

Añadir y modificar

Con []= añades una clave nueva o cambias el valor de una existente. store hace lo mismo:

contactos = { alberto: "600000000", barreto: "611111111" }

contactos[:alberto] = "644444444"   # cambia un valor
contactos[:dario] = "622222222"     # añade una clave
contactos.store(:candido, "633333333")

p contactos
# => {alberto: "644444444", barreto: "611111111", dario: "622222222", candido: "633333333"}

Para quitar una pareja, usa delete, que además devuelve el valor borrado: contactos.delete(:candido).

Fusionar con merge

merge no modifica el hash original: devuelve uno nuevo con las parejas de los dos. Si quieres modificar el original, usa merge!.

contactos = { alberto: "600000000", barreto: "611111111" }
nuevos = contactos.merge({ dario: "622222222" })

p contactos  # => {alberto: "600000000", barreto: "611111111"}
p nuevos     # => {alberto: "600000000", barreto: "611111111", dario: "622222222"}

Consultar

Quieres saber… Método Resultado con { alberto: "600000000", barreto: "611111111" }
Cuántas parejas hay length o size 2
Todas las claves keys [:alberto, :barreto]
Todos los valores values ["600000000", "611111111"]
Si existe una clave key?(:alberto) true
Si existe un valor value?("600000000") true

has_key? y has_value? también funcionan; son nombres antiguos de key? y value?.

fetch: cuando la clave debe existir

contactos[:daniel] devuelve nil en silencio, y ese nil puede dar un error mucho más adelante. fetch falla en el momento o te deja dar un valor por defecto:

contactos.fetch(:alberto)                   # => "600000000"
contactos.fetch(:daniel)                    # KeyError: key not found: :daniel
contactos.fetch(:daniel, "sin teléfono")    # => "sin teléfono"

Cómo capturar ese KeyError se explica en Excepciones en Ruby.

Recorrer un hash

each te da cada clave con su valor:

contactos.each do |nombre, telefono|
  puts "#{nombre}: #{telefono}"
end
# alberto: 600000000
# barreto: 611111111

Fuentes

  • Documentación oficial de Hash (Ruby 4.0).
  • Todos los ejemplos se han ejecutado con Ruby 4.0.9 (imagen oficial ruby:latest de Docker) en noviembre de 2026. Desde Ruby 3.4, p e inspect muestran los hashes con el formato {alberto: "…"} en lugar de {:alberto=>"…"}.