Arrays na hashes hufanya kazi vipi?

Question

Accepted Answer

**Arrays** ni mikusanyiko iliyopangwa kwa mpangilio; **hashes** ni mikusanyiko ya key-value (kama dictionaries/maps). Ni miundo miwili mikuu ya data ya Ruby, vyote vikiwa na methods tajiri na zenye uwazi (kwa kiasi kikubwa kutoka kwa module ya Enumerable) zinazofanya udhibiti wa data kuwa wa kuvutia.

## Arrays — mikusanyiko iliyopangwa

```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 ni za kidaynamiki, zilizopangwa, zenye index (zikiwa na usaidizi wa negative-index), na zina seti tajiri ya methods (`map`, `select`, `reduce`, n.k.) kwa uchakataji wa data wa kuvutia.

## Hashes — mikusanyiko ya key-value

```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 hupatanisha keys na values. Sintaksia ya kiidiomu inatumia **symbol keys** (`{ name: "Ann" }`), na hashes zina methods tajiri kwa ufikiaji, iteration, na ubadilishaji. `fetch` hutoa ufikiaji salama (ukiwa na default au error kwa keys zinazokosekana).

## Patterns muhimu

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

## Kwa nini ni muhimu

Arrays na hashes ni miundo ya msingi ya data ya Ruby — inayotumika mara kwa mara kwa kuhifadhi na kuchakata mikusanyiko ya data — hivyo kuzimudu ni maarifa muhimu ya kila siku. **Arrays** (mikusanyiko iliyopangwa, yenye index ikiwa na usaidizi wa negative-index) na **hashes** (maps za key-value) zinafunika idadi kubwa ya mahitaji ya ushughulikiaji wa data (orodha, records, configuration, data inayofanana na JSON).

Kinachozifanya kuwa zenye nguvu hasa katika Ruby ni **maktaba yao tajiri na yenye uwazi ya methods** (kwa kiasi kikubwa kutoka kwa module ya Enumerable) — `map`, `select`, `reduce`, `each`, na dazeni zaidi — zinazokuwezesha kubadilisha, kuchuja, na kuchakata data kwa uvutio kwa msimbo mfupi na unaosomeka badala ya loops ndefu, ukijumuisha mtindo wa uwazi wa Ruby.

Kujua desturi za kiidiomu — hasa **symbol keys kwa hashes** (`{ name: "Ann" }`) na patterns muhimu kama `Hash.new(0)` kwa default values, `fetch` kwa ufikiaji salama, na nested structures kwa data ngumu — ni muhimu kwa kuandika Ruby safi, ya kiidiomu.

Kwa kuwa arrays na hashes hujitokeza katika takriban kila programu ya Ruby, na kwa kuwa methods zao tajiri ni kiini cha mtindo wa kuvutia wa uchakataji wa data wa Ruby (na wa kufanya kazi na Rails, JSON, na APIs), ufasaha nazo — kuunda, kufikia, ku-iterate, na kubadilisha arrays na hashes kwa methods zao zenye uwazi — ni maarifa ya msingi, ya lazima kujua yanayoshikilia uendelezaji bora, wa kiidiomu wa Ruby.