Struct என்றால் என்ன மற்றும் எப்போது நீங்கள் அதைப் பயன்படுத்துகிறீர்கள்?

Question

Accepted Answer

**`Struct`** என்பது Ruby இல் உள்ளமைக்கப்பட்ட ஒரு வகுப்பாகும், இது சில **attributes** ஐ ஒன்றாக கட்டுமான செய்து எளிய வகுப்புகளை விரைவாக உருவாக்குவதற்கு பயன்படுகிறது — constructor, accessors, equality மற்றும் பலவற்றை தானாக உৎपादிக்கிறது. ஒரு முழுமையான வகுப்பை எழுதாமல் இலகு தரவு வகுப்புகளை வரையறுப்பதற்கான ஒரு சுருக்கமான வழி இது.

## Struct தீர்க்கும் பிரச்சனை

```ruby
# ❌ a full class for simple data is verbose boilerplate
class Point
  attr_accessor :x, :y
  def initialize(x, y)
    @x = x
    @y = y
  end
  def ==(other)
    x == other.x && y == other.y
  end
end

# ✅ Struct does all of that in ONE line
Point = Struct.new(:x, :y)
```

`Struct.new(:x, :y)` என்பது constructor உடன் ஒரு வகுப்பை உৎபாதிக்கிறது, `x` மற்றும் `y` க்கான `attr_accessor`s, value-based equality, `to_s`, மற்றும் பலவும் — எளிய தரவு வகுப்பின் boilerplate ஐ நீக்குகிறது.

## Struct ஐப் பயன்படுத்துதல்

```ruby
Point = Struct.new(:x, :y)

p = Point.new(1, 2)
p.x              # 1 — accessor generated
p.y = 5           # setter generated
p == Point.new(1, 5)   # true — VALUE-based equality (generated)
p.to_a            # [1, 5] — convertible

# Structs can have methods too
Point = Struct.new(:x, :y) do
  def distance_from_origin
    Math.sqrt(x**2 + y**2)
  end
end
Point.new(3, 4).distance_from_origin   # 5.0
```

Structs accessors மற்றும் **value-based equality** ஐ வழங்குகிறது (சமान attributes உடைய இரண்டு structs சமம் — தரவு பொருள்களுக்கு வசதிகரமாக உள்ளது), மற்றும் நீங்கள் ஒரு தொகுப்பில் custom methods களைச் சேர்க்கலாம்.

## Keyword-initialized structs மற்றும் Data (Ruby 3.2)

```ruby
# keyword arguments (clearer for many fields)
Point = Struct.new(:x, :y, keyword_init: true)
Point.new(x: 1, y: 2)

# Data (Ruby 3.2+) — an IMMUTABLE alternative to Struct (for value objects)
Point = Data.define(:x, :y)
p = Point.new(1, 2)
p.x              # 1 (read-only — immutable)
p2 = p.with(x: 5)  # non-destructive copy with a change
```

Ruby 3.2 இல் **`Data`** என்பது Struct இன் immutable variant ஆகும் — மாறக்கூடாத value objects க்கு சிறந்ததாக உள்ளது.

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

`Struct` என்பது **விரைவாக எளிய தரவு வகுப்புகளை உருவாக்குவதற்கான** boilerplate இல்லாமல் ஒரு பயனுள்ள Ruby feature ஆகும், எனவே இதைப் புரிந்துகொள்வது சுருக்கமான, சுத்தமான Ruby ஐ எழுதுவதற்கு மதிப்புள்ளதாக இருக்கிறது.

மূல நன்மை என்பது எளிய தரவு-holding வகுப்பு தேவைப்படும் repetitive code ஐ நீக்குவதாகும் — constructor, `attr_accessor`s, மற்றும் equality உடன் ஒரு முழுமையான வகுப்பை எழுதுவதற்கு பதிலாக, `Struct.new(:x, :y)` அனைத்தையும் ஒரு வரியில் உৎபாதிக்கிறது, **value-based equality** (சமான attributes உடைய இரண்டு structs சமம், இது தரவு பொருள்களுக்கு நீங்கள் விரும்புவது மற்றும் வழக்கமான வகுப்புகளின் reference equality ஐ விட வேறுபட்டது) உட்பட.

இது இலகு தரவு கட்டமைப்புகள், value objects, முறைகளிலிருந்து grouped values திரும்பப் பெறுதல், மற்றும் எளிய records க்கு Struct ஐ சிறந்ததாக்குகிறது, இதில் ஒரு முழுமையான வகுப்பு மிகவும் அதிக இருக்கும் — code ஐ சுருக்கமாக வைக்கும் ஒரு practical productivity tool.

Struct ஐ புரிந்துகொள்வது (generated accessors மற்றும் value equality உடன் சுருக்கமான தரவு வகுப்புகள், custom methods களைச் சேர்க்க கூடிய திறன் உட்பட), keyword-initialized structs (பல fields க்கு தெளிவாக), மற்றும் modern **`Data`** வகுப்பு (Ruby 3.2 இன் immutable alternative மாறக்கூடாத value objects க்கு) என்பது எளிய தரவை elegantly முறையாக்கும் மதிப்புள்ள அறிவாகும்.

சிறிய தரவு வகுப்புகளை வரையறுப்பது ஒரு பொதுவான தேவை என்பதற்கு, மற்றும் Struct (மற்றும் Data) இதைச் செய்ய ஒரு சுருக்கமான, idiomatic வழியை வழங்குவதற்கு — useful generated behavior உடன் (குறிப்பாக value equality) — Struct/Data க்கு எப்போது வந்து சொல்லலாம் மற்றும் ஒரு முழுமையான வகுப்பு என்பது practically-relevant Ruby அறிவாகும் சுத்தமான, சுருக்கமான code எழுதுவதை பிரதிபலிக்கிறது — Ruby developer இன் toolkit இல் ஒரு பயனுள்ள tool தொடர்பான attributes ஐ ஒரு இலகு type இல் bundling செய்ய பொதுவான task க்கு, Ruby இன் conciseness மற்றும் boilerplate ஐ குறைப்பதன் மீது emphasis வெளிப்படுத்துகிறது.