arrays और hashes कैसे काम करते हैं?

Question

Accepted Answer

**Arrays** ordered collections हैं; **hashes** key-value collections हैं (dictionaries/maps की तरह)। ये Ruby की दो मुख्य data structures हैं, दोनों में समृद्ध, अभिव्यंजक methods हैं (मुख्य रूप से Enumerable module से) जो data manipulation को सुंदर बनाते हैं।

## 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 के लिए methods का एक समृद्ध सेट रखते हैं (`map`, `select`, `reduce`, आदि)।

## 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 के लिए समृद्ध 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 की मूलभूत data structures हैं — data के collections को संग्रहित और process करने के लिए लगातार उपयोग होते हैं — इसलिए इन पर महारत हासिल करना आवश्यक रोज़मर्रा का ज्ञान है। **Arrays** (ordered, indexed collections negative-index support के साथ) और **hashes** (key-value maps) data-handling की अधिकांश आवश्यकताओं को कवर करते हैं (lists, records, configuration, JSON-like data)।

जो उन्हें Ruby में विशेष रूप से शक्तिशाली बनाता है वह है उनकी **समृद्ध, अभिव्यंजक method library** (मुख्य रूप से Enumerable module से) — `map`, `select`, `reduce`, `each`, और दर्जनों और — जो आपको verbose loops के बजाय संक्षिप्त, पठनीय code के साथ data को सुंदर ढंग से transform, filter, और process करने देते हैं, Ruby की अभिव्यंजक शैली को मूर्त रूप देते हैं।

idiomatic परंपराओं को जानना — विशेष रूप से **hashes के लिए symbol keys** (`{ name: "Ann" }`) और उपयोगी patterns जैसे default values के लिए `Hash.new(0)`, safe access के लिए `fetch`, और complex data के लिए nested structures — साफ़, idiomatic Ruby लिखने के लिए महत्वपूर्ण है।

चूँकि arrays और hashes वस्तुतः हर Ruby program में आते हैं, और चूँकि उनके समृद्ध methods Ruby की elegant data-processing शैली के केंद्र में हैं (और Rails, JSON, और APIs के साथ काम करने के लिए), उनमें प्रवाह — arrays और hashes को उनके अभिव्यंजक methods के साथ बनाना, access करना, iterate करना, और transform करना — मूलभूत, अवश्य-जानने योग्य ज्ञान है जो प्रभावी, idiomatic Ruby विकास का आधार है।