Come funzionano gli array e gli hash?

Question

Accepted Answer

**Array** sono collezioni ordinate; **hash** sono collezioni chiave-valore (come dizionari/mappe). Sono le due principali strutture dati di Ruby, entrambe con metodi ricchi ed espressivi (principalmente dal modulo Enumerable) che rendono la manipolazione dei dati elegante.

## Array — collezioni ordinate

```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
```

Gli array sono dinamici, ordinati, indicizzati (con supporto per indici negativi), e hanno un set ricco di metodi (`map`, `select`, `reduce`, ecc.) per l'elaborazione elegante dei dati.

## Hash — collezioni chiave-valore

```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}" }
```

Gli hash mappano chiavi a valori. La sintassi idiomatica usa **chiavi simbolo** (`{ name: "Ann" }`), e gli hash hanno metodi ricchi per l'accesso, l'iterazione e la trasformazione. `fetch` fornisce un accesso sicuro (con un valore predefinito o errore per chiavi mancanti).

## Pattern utili

```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"
```

## Perché è importante

Array e hash sono le strutture dati fondamentali di Ruby — usate costantemente per memorizzare ed elaborare collezioni di dati — quindi padroneggiarli è una conoscenza essenziale quotidiana. **Array** (collezioni ordinate, indicizzate con supporto per indici negativi) e **hash** (mappe chiave-valore) coprono la stragrande maggioranza delle esigenze di gestione dei dati (liste, record, configurazione, dati simili a JSON).

Ciò che le rende particolarmente potenti in Ruby è la loro **libreria di metodi ricca ed espressiva** (principalmente dal modulo Enumerable) — `map`, `select`, `reduce`, `each`, e dozzine di altri — che ti permettono di trasformare, filtrare ed elaborare i dati elegantemente con codice conciso e leggibile piuttosto che loop prolissi, incarnando lo stile espressivo di Ruby.

Conoscere le convenzioni idiomatiche — soprattutto **chiavi simbolo per gli hash** (`{ name: "Ann" }`) e pattern utili come `Hash.new(0)` per valori predefiniti, `fetch` per l'accesso sicuro, e strutture annidate per dati complessi — è importante per scrivere Ruby pulito e idiomatico.

Poiché array e hash appaiono in praticamente ogni programma Ruby, e poiché i loro metodi ricchi sono centrali nello stile di elaborazione elegante dei dati di Ruby (e nel lavoro con Rails, JSON, e API), la fluidità con essi — creazione, accesso, iterazione e trasformazione di array e hash con i loro metodi espressivi — è una conoscenza fondamentale e indispensabile che sottende lo sviluppo Ruby efficace e idiomatico.