¿Cómo funcionan los arrays y los hashes?

Question

Accepted Answer

**Arrays** son colecciones ordenadas; **hashes** son colecciones clave-valor (como diccionarios/mapas). Son las dos estructuras de datos principales de Ruby, ambas con un conjunto rico y expresivo de métodos (en gran medida del módulo Enumerable) que hacen que la manipulación de datos sea elegante.

## Arrays — colecciones ordenadas

```ruby
fruits = ["apple", "banana", "cherry"]
fruits[0]               # "apple" — index access
fruits[-1]              # "cherry" — negative indexes from the end
fruits << "date"        # append (or .push)
fruits.length           # size
fruits.include?("apple") # membership

# Ruby's elegant array methods (from Enumerable)
fruits.map { |f| f.upcase }          # transform each
fruits.select { |f| f.length > 5 }   # filter
fruits.each { |f| puts f }           # iterate
[3, 1, 2].sort                       # [1, 2, 3]
[1, 2, 3].sum                        # 6
```

Los arrays son dinámicos, ordenados, indexados (con soporte de índices negativos) y tienen un conjunto rico de métodos (`map`, `select`, `reduce`, etc.) para un procesamiento de datos elegante.

## Hashes — colecciones clave-valor

```ruby
# symbol keys (the idiom) with modern syntax
user = { name: "Ann", age: 30, role: :admin }
user[:name]             # "Ann" — access by key
user[:email] = "a@x.com"  # add/set
user.key?(:name)         # check key existence
user.fetch(:name)        # access with an error if missing (or a default)

# iterate key-value pairs
user.each { |key, value| puts "#{key}: #{value}" }
user.keys; user.values
user.map { |k, v| "#{k}=#{v}" }
```

Los hashes mapean claves a valores. La sintaxis idiomática utiliza **claves símbolo** (`{ name: "Ann" }`), y los hashes tienen métodos ricos para acceso, iteración y transformación. `fetch` proporciona acceso seguro (con un valor por defecto o error para claves faltantes).

## Patrones útiles

```ruby
# default values
counts = Hash.new(0)
counts[:x] += 1         # works even though :x wasn't set (default 0)

# nested structures (common for JSON-like data)
data = { users: [{ name: "Ann" }, { name: "Bob" }] }
data[:users].first[:name]    # "Ann"
```

## Por qué es importante

Los arrays y hashes son las estructuras de datos fundamentales de Ruby — se utilizan constantemente para almacenar y procesar colecciones de datos — por lo que dominarlos es conocimiento esencial cotidiano. **Arrays** (colecciones ordenadas e indexadas con soporte de índices negativos) y **hashes** (mapas clave-valor) cubren la gran mayoría de necesidades de manejo de datos (listas, registros, configuración, datos tipo JSON).

Lo que las hace particularmente poderosas en Ruby es su **biblioteca de métodos rica y expresiva** (en gran medida del módulo Enumerable) — `map`, `select`, `reduce`, `each` y docenas más — que te permiten transformar, filtrar y procesar datos elegantemente con código conciso y legible en lugar de bucles verbosos, encarnando el estilo expresivo de Ruby.

Conocer las convenciones idiomáticas — especialmente **claves símbolo para hashes** (`{ name: "Ann" }`) y patrones útiles como `Hash.new(0)` para valores por defecto, `fetch` para acceso seguro y estructuras anidadas para datos complejos — es importante para escribir Ruby limpio e idiomático.

Ya que los arrays y hashes aparecen en prácticamente todo programa Ruby, y ya que sus métodos ricos son centrales al estilo elegante de procesamiento de datos de Ruby (y al trabajar con Rails, JSON y APIs), la fluidez con ellos — crear, acceder, iterar y transformar arrays y hashes con sus métodos expresivos — es conocimiento fundamental y esencial que sustenta el desarrollo Ruby efectivo e idiomático.