arrays మరియు hashes ఎలా పని చేస్తాయి?

Question

Accepted Answer

**Arrays** అనేవి ordered collections; **hashes** అనేవి key-value collections (dictionaries/maps లాంటివి). ఇవి Ruby యొక్క రెండు ప్రధాన data structures, రెండూ సমృద్ధమైన, expressive methods (ఎక్కువగా Enumerable module నుండి) కలిగి ఉన్నాయి, ఇవి data manipulation ను elegant చేస్తాయి.

## Arrays — ordered collections

```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 dynamic, ordered, indexed (negative-index support కలిగి), మరియు elegant data processing కోసం rich set of methods (`map`, `select`, `reduce`, etc.) కలిగి ఉన్నాయి.

## Hashes — key-value collections

```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 keys ని values కి map చేస్తాయి. Idiomatic syntax **symbol keys** (`{ name: "Ann" }`) ను ఉపయోగించటం, మరియు hashes access, iteration, మరియు transformation కోసం rich methods కలిగి ఉన్నాయి. `fetch` safe access ను ఇస్తుంది (missing keys కోసం default లేదా error తో).

## Useful patterns

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

## ఇది ఎందుకు ముఖ్యమైనది

Arrays మరియు hashes Ruby యొక్క fundamental data structures — data collections ని store మరియు process చేయటానికి ఎప్పుడూ ఉపయోగిస్తారు — కాబట్టి వాటిని master చేయటం essential everyday knowledge. **Arrays** (ordered, indexed collections negative-index support తో) మరియు **hashes** (key-value maps) data-handling needs (lists, records, configuration, JSON-like data) యొక్క vast majority ను cover చేస్తాయి.

Ruby లో వాటిని ముఖ్యంగా శక్తిశాలిగా చేసేది వాటి **rich, expressive method library** (ఎక్కువగా Enumerable module నుండి) — `map`, `select`, `reduce`, `each`, మరియు డజన్ల ఆపైన — ఇవి మీకు verbose loops కంటే data ను elegant మరియు concise, readable code కలిగిన transform, filter, మరియు process చేయటానికి అనుమతిస్తాయి, Ruby యొక్క expressive style ను embodying చేస్తాయి.

Idiomatic conventions ను తెలుసుకోవటం — ముఖ్యంగా **symbol keys for hashes** (`{ name: "Ann" }`) మరియు useful patterns లాంటి `Hash.new(0)` default values కోసం, `fetch` safe access కోసం, మరియు nested structures complex data కోసం — clean, idiomatic Ruby ను writing చేయటానికి ముఖ్యమైనది.

Arrays మరియు hashes virtually every Ruby program లో కనిపిస్తాయి, మరియు వాటి rich methods Ruby యొక్క elegant data-processing style కు (మరియు Rails, JSON, మరియు APIs తో working కు) central కాబట్టి, fluency వాటితో — creating, accessing, iterating, మరియు transforming arrays మరియు hashes వాటి expressive methods తో — foundational, must-know knowledge ఇది effective, idiomatic Ruby development కు underpins చేస్తుంది.