Jak działają tablice i hashe?

Question

Accepted Answer

**Tablice** to kolekcje uporządkowane; **hashe** to kolekcje klucz-wartość (jak słowniki/mapy). Są to dwie główne struktury danych w Ruby, obie posiadające bogaty zestaw metod (w dużej mierze z modułu Enumerable), które sprawiają, że manipulacja danymi jest elegancka.

## Tablice — kolekcje uporządkowane

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

Tablice są dynamiczne, uporządkowane, indeksowane (ze wsparciem dla indeksów ujemnych) i posiadają bogaty zestaw metod (`map`, `select`, `reduce`, itp.) dla eleganckich operacji na danych.

## Hashe — kolekcje klucz-wartość

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

Hashe mapują klucze na wartości. Idiomatyczna składnia używa **kluczy symbolicznych** (`{ name: "Ann" }`), a hashe posiadają bogate metody do dostępu, iteracji i transformacji. `fetch` zapewnia bezpieczny dostęp (z wartością domyślną lub błędem dla brakujących kluczy).

## Przydatne wzorce

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

## Dlaczego to ważne

Tablice i hashe są fundamentalnymi strukturami danych Ruby — używane nieustannie do przechowywania i przetwarzania zbiorów danych — więc opanowanie ich jest niezbędną wiedzą na co dzień. **Tablice** (uporządkowane, indeksowane kolekcje ze wsparciem dla indeksów ujemnych) i **hashe** (mapy klucz-wartość) obejmują zdecydowaną większość potrzeb związanych z obsługą danych (listy, rekordy, konfiguracja, dane podobne do JSON).

To, co czyni je szczególnie potężnymi w Ruby, to ich **bogata, ekspresywna biblioteka metod** (w dużej mierze z modułu Enumerable) — `map`, `select`, `reduce`, `each` i wiele innych — które pozwalają przekształcać, filtrować i przetwarzać dane elegancko za pomocą zwięzłego, czytelnego kodu zamiast złożonych pętli, wcielając ekspresywny styl Ruby.

Znajomość idiomatycznych konwencji — zwłaszcza **kluczy symbolicznych dla hashów** (`{ name: "Ann" }`) i przydatnych wzorców takich jak `Hash.new(0)` dla wartości domyślnych, `fetch` dla bezpiecznego dostępu i zagnieżdżonych struktur dla złożonych danych — jest ważna dla pisania czystego, idiomatycznego Ruby.

Ponieważ tablice i hashe pojawiają się praktycznie w każdym programie Ruby, a ich bogate metody są centralne dla elegancyjnego stylu przetwarzania danych w Ruby (a także do pracy z Rails, JSON i API), biegłość z nimi — tworzenie, dostęp, iteracja i transformacja tablic i hashów za pomocą ich ekspresywnych metod — jest fundamentalną, niezbędną wiedzą, która stanowi podstawę efektywnego, idiomatycznego rozwoju Ruby.