Hogyan működnek a tömbök és a hash-ek?

Question

Accepted Answer

A **tömbök** rendezett kollekciók; a **hash-ek** kulcs-érték kollekciók (mint a szótárak/maps). Ezek a Ruby két fő adatszerkezete, mindkettőnek gazdag, kifejező metódusai vannak (nagyrészt az Enumerable modulból), amelyek az adatkezelést elegánssá teszik.

## Tömbök — rendezett kollekciók

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

A tömbök dinamikusak, rendezettek, indexeltek (negatív indexek támogatásával), és gazdag metóduskészlettel rendelkeznek (`map`, `select`, `reduce`, stb.) az elegáns adatfeldolgozáshoz.

## Hash-ek — kulcs-érték kollekciók

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

A hash-ek kulcsokat értékekhez rendelik. Az idiomatikus szintaxis **szimbólumkulcsokat** használ (`{ name: "Ann" }`), és a hash-ek gazdag metódusokkal rendelkeznek az eléréshez, iterációhoz és transzformációhoz. A `fetch` biztonságos hozzáférést biztosít (alapértelmezett értékkel vagy hibával hiányzó kulcsok esetén).

## Hasznos minták

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

## Miért fontos

A tömbök és hash-ek a Ruby alapvető adatszerkezetei — állandóan használatosak adatgyűjtemények tárolásához és feldolgozásához —, ezért ezeket elsajátítani alapvető, napi tudás. A **tömbök** (rendezett, indexelt kollekciók negatív indexek támogatásával) és a **hash-ek** (kulcs-érték leképezések) az adatkezelési igények nagy többségét lefedik (listák, rekordok, konfiguráció, JSON-szerű adatok).

Az, ami különösen erőssé teszi őket a Ruby-ban, a **gazdag, kifejező metóduskönyvtáruk** (nagyrészt az Enumerable modulból) — `map`, `select`, `reduce`, `each` és sok más —, amely lehetővé teszi az adatok transzformálását, szűrését és feldolgozását elegánsan, tömör, olvasható kóddal, ahelyett, hogy hosszadalmas ciklusokat kellene írni, megtestesítve a Ruby kifejező stílusát.

Az idiomatikus konvenciók ismerete — különösen a **szimbólumkulcsok hash-ekhez** (`{ name: "Ann" }`) és hasznos minták, mint a `Hash.new(0)` alapértelmezett értékekhez, a `fetch` biztonságos hozzáféréshez, és beágyazott szerkezetek összetett adatokhoz — fontos a tiszta, idiomatikus Ruby írásához.

Mivel a tömbök és hash-ek szinte minden Ruby-programban megjelennek, és mivel gazdag metódusaik a Ruby elegáns adatfeldolgozási stílusának központjában vannak (valamint a Rails-el, a JSON-nel és az API-kkal való munkavégzésben), az ezekkel való jártasság — tömbök és hash-ek létrehozása, elérése, iterációja és transzformációja kifejező metódusaikkal — alapvető, szükséges tudás, amely az effektív, idiomatikus Ruby fejlesztés alapját képezi.