வரிசைகள் (Arrays) மற்றும் ஹ்যாஷ் (Hashes) எவ்வாறு செயல்படுகின்றன?

Question

Accepted Answer

**வரிசைகள்** என்பன வரிசைப்படுத்தப்பட்ட சேகரணைகள்; **ஹ்যாஷ்** என்பன முக்கிய-மதிப்பு சேகரணைகள் (அகராதி/வரைபடங்களைப் போல). இவை Ruby-ன் இரண்டு முக்கிய தரவு அமைப்புகள், இரண்டும் செழுமையான, வெளிப்பாட்டுத் முறையிலான முறைகளுடன் (பெரும்பாலும் Enumerable மாடியூலிலிருந்து) இருந்து தரவு கையாளுதல் நேர்த்தியாக இருக்கிறது.

## வரிசைகள் — வரிசைப்படுத்தப்பட்ட சேகரணைகள்

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

வரிசைகள் இயங்கும், வரிசைப்படுத்தப்பட்ட, குறியிடப்பட்ட (எதிர்மறை-குறியீட்டு ஆதரவு கொண்ட), மற்றும் செழுமையான முறைகளின் தொகுப்புகளை (`map`, `select`, `reduce`, முதலியன) நேர்த்தியான தரவு செயலாக்கத்திற்காக கொண்டுள்ளன.

## ஹ்யாஷ் — முக்கிய-மதிப்பு சேகரணைகள்

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

ஹ்யாஷ் முக்கிய சொற்களை மதிப்புகளுக்கு வரைபடமிடுகிறது. சொற்பொழிவுசார் தொடரியல் **சின்ன முக்கிய சொற்களை** (`{ name: "Ann" }`) பயன்படுத்துகிறது, மற்றும் ஹ்யாஷ் அணுகல், மறு மீடல் மற்றும் மாற்றத்திற்கான செழுமையான முறைகளை கொண்டுள்ளன. `fetch` காணாமல் போன முக்கிய சொற்களுக்கான பாதுகாப்பான அணுகல் (இயல்பு அல்லது பிழை) வழங்குகிறது.

## பயனுள்ள வடிவங்கள்

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

## இது ஏன் முக்கியமானது

வரிசைகள் மற்றும் ஹ்யாஷ் Ruby-ன் அடிப்படை தரவு அமைப்புகள் — தரவு சேகரணைகளை சேமிக்க மற்றும் செயலாக்க பொதுவாக பயன்படுத்தப்படுகிறது — எனவே அவற்றைக் கற்றுக்கொள்வது அவசியமான தினசரி அறிவு. **வரிசைகள்** (வரிசைப்படுத்தப்பட்ட, குறியிடப்பட்ட சேகரணைகள் எதிர்மறை-குறியீட்டு ஆதரவுடன்) மற்றும் **ஹ்யாஷ்** (முக்கிய-மதிப்பு வரைபடங்கள்) தரவு-கையாளுதல் தேவைகளின் பெரும்பகுதியை கவர் செய்கிறது (பட்டியல்கள், பதிவுகள், உள்ளமைவு, JSON போன்ற தரவு).

Ruby-ல் அவற்றை குறிப்பாக சக்திசாலி செய்பவை அவற்றின் **செழுமையான, வெளிப்பாட்டுத் முறையிலான முறை நூலகம்** (பெரும்பாலும் Enumerable மாடியூலிலிருந்து) — `map`, `select`, `reduce`, `each`, மற்றும் பல — இது தரவை மாற்றவும், வடிகட்டவும், செயலாக்கவும் உங்களை அனுமதிக்கிறது வெளிப்படையான நூல் சுற்றுகளைக் காட்டிலும் Ruby-ன் வெளிப்பாட்டுத் முறை உள்ளக்கூறை உணர்ந்து.

சொற்பொழிவுசார் மரபுகளை அறிதல் — குறிப்பாக **சின்ன முக்கிய சொற்களுக்கான ஹ்யாஷ்** (`{ name: "Ann" }`) மற்றும் `Hash.new(0)` இயல்பு மதிப்புக்கான, `fetch` பாதுகாப்பான அணுகல்க்கான, மற்றும் சிக்கல்யான தரவுக்கான உட்கூற்று அமைப்புக்கான பயனுள்ள வடிவங்கள் — சுத்தமான, சொற்பொழிவுசார் Ruby எழுதுவதற்கு முக்கியமாக உள்ளது.

வரிசைகள் மற்றும் ஹ்யாஷ் ন்ன்ற கிட்டத்தட்ட ஒவ்வொரு Ruby நிரலிலும் தோன்றுவதால், மற்றும் அவற்றின் செழுமையான முறைகள் Ruby-ன் நேர்த்திய தரவு-செயலாக்கனை வடிவமை செய்வதற்கு மையமாக இருப்பதால் (மற்றும் Rails, JSON, மற்றும் APIs-ன் கூட), வரிசைகள் மற்றும் ஹ்யாஷ்-ல் பாவனை — உருவாக்கல், அணுகல், மறு மீடல், மற்றும் அவற்றின் வெளிப்பாட்டுத் முறையிலான முறைகளுடன் மாற்றுதல் — அடிப்படை, அবசியமாக அறிய வேண்டிய அறிவு இது प्रभावी, சொற்பொழிவுசார் Ruby மேம்பாட்டு அடிப்படையாக இருக்கிறது.