Arrays da Hashes suke aiki ta yaya?

Question

Accepted Answer

**Arrays** su ne tarin ƴarwa; **hashes** su ne tarin maɓalli-ƙima (kamar dictionaries/maps). Su ne babbar tsarin bayanan Ruby guda biyu, duka suna da hanyoyin yawa masu ƙarfi (mafi yawa daga Enumerable module) wanda ke sa juyawa na bayanan mai haske.

## Arrays — tarin ƴarwa

```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 sun kasance masu canji, ƴarwa, mai jajere (tare da goyan neg-index), kuma suna da tsarin hanyoyin yawa mai ƙarfi (`map`, `select`, `reduce`, jne.) don mahimmin jujjuya data.

## Hashes — tarin maɓalli-ƙima

```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 sun mappas maɓalli zuwa ƙima. Sassan dalilin idiomatik sun yi amfani da **symbol keys** (`{ name: "Ann" }`), kuma hashes suna da hanyoyin yawa mai ƙarfi don samewa, ɗaukar nauyi, da sauyi. `fetch` yana ba da amfani lafiya (tare da matsala ko kuskure don maɓallai waɗanda ba su akanta).

## Tsarin amfani mai amfani

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

## Me yake da muhimmanci

Arrays da hashes su ne mahimman tsarin bayanan Ruby — ana amfani da su a kullum don ajiye da kula da tarin ƙaramin bayanan — saboda haka kula da su shine ilimin kullum. **Arrays** (ƴarwa, tarin da jajere mai goyan ga index mara) da **hashes** (maɓalli-ƙima maps) sun rufe jilar yawa na buƙatun jiyya-maɓalli (jerin, bayanan, ƙarnitin, JSON kamar data).

Abin da yake sa su kasance mai ƙarfi sosai a Ruby shi ne **library mai ƙarfi, mai faskewa** (mafi yawa daga Enumerable module) — `map`, `select`, `reduce`, `each`, da ƙarami — wanda ke ba da damar juyawa, binciko, da kula da bayanan tare da sakamako mai haske tare da sakamako mai gajiya maimakon hanyoyin maimakon maimakon, da aka sanya daka ruby tsarin faskewa.

Sanin sassan dalilin — musamman **symbol keys para hashes** (`{ name: "Ann" }`) da tsarin amfani mai amfani kamar `Hash.new(0)` don ƙimar matsala, `fetch` don amfani lafiya, da tsarin kuɓni don bayanan masu rikitarwa — shi ne muhimmi don rubuta tsari, tsarin Ruby.

Tun da arrays da hashes suna bayyana a fiye da kowane Ruby program, kuma tun da hanyoyinsu mai ƙarfi su ne mahimmi ga ruby tsarin faskewa-juyawa (kuma ga aiki tare da Rails, JSON, da APIs), hazaka tare da su — sarrafa, samewa, ɗaukar nauyi, da sauyi arrays da hashes tare da hanyoyinsu mai faskewa — shi ne mahimmin, dole-doler ilimin da yake taurin babbar, idiomatic Ruby ci gaba.