Como arrays e hashes funcionam?

Question

Accepted Answer

**Arrays** são coleções ordenadas; **hashes** são coleções de chave-valor (como dicionários/mapas). São as duas principais estruturas de dados do Ruby, ambas com métodos ricos e expressivos (em grande parte do módulo Enumerable) que tornam a manipulação de dados elegante.

## Arrays — coleções 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
```

Arrays são dinâmicos, ordenados, indexados (com suporte a índices negativos), e têm um conjunto rico de métodos (`map`, `select`, `reduce`, etc.) para processamento elegante de dados.

## Hashes — coleções de chave-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}" }
```

Hashes mapeiam chaves para valores. A sintaxe idiomática usa **chaves símbolo** (`{ name: "Ann" }`), e hashes têm métodos ricos para acesso, iteração e transformação. `fetch` fornece acesso seguro (com um padrão ou erro para chaves faltantes).

## Padrões úteis

```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 que isso importa

Arrays e hashes são as estruturas de dados fundamentais do Ruby — usadas constantemente para armazenar e processar coleções de dados — então dominá-los é conhecimento essencial do dia a dia. **Arrays** (coleções ordenadas e indexadas com suporte a índices negativos) e **hashes** (mapas de chave-valor) cobrem a vast maioria das necessidades de manipulação de dados (listas, registros, configuração, dados em formato JSON).

O que as torna particularmente poderosas em Ruby é sua **biblioteca de métodos rica e expressiva** (em grande parte do módulo Enumerable) — `map`, `select`, `reduce`, `each`, e dezenas mais — que permitem transformar, filtrar e processar dados elegantemente com código conciso e legível em vez de loops verbosos, incorporando o estilo expressivo do Ruby.

Conhecer as convenções idiomáticas — especialmente **chaves símbolo para hashes** (`{ name: "Ann" }`) e padrões úteis como `Hash.new(0)` para valores padrão, `fetch` para acesso seguro, e estruturas aninhadas para dados complexos — é importante para escrever Ruby limpo e idiomático.

Já que arrays e hashes aparecem em praticamente todo programa Ruby, e já que seus métodos ricos são centrais para o estilo elegante de processamento de dados do Ruby (e para trabalhar com Rails, JSON e APIs), fluência com eles — criação, acesso, iteração e transformação de arrays e hashes com seus métodos expressivos — é conhecimento fundamental e imprescindível que sustenta o desenvolvimento Ruby eficaz e idiomático.