Struct అంటే ఏమిటి మరియు మీరు దానిని ఎప్పుడు ఉపయోగిస్తారు?

Question

Accepted Answer

**`Struct`** అనేది Ruby లో కొన్ని **attributes** ను కలిపి సరళమైన క్లాసులను త్వరగా సృష్టించడానికి ఉపయోగించే built-in క్లాస్ — కన్‌స్ట్రక్టర్, accessors, equality మరియు మరిన్నీ ఆటోమేటిక్‌గా జెనరేట్ చేస్తుంది. సంపూర్ణ క్లాస్ వ్రాయకుండా lightweight డేటా క్లాసులను నిర్వచించే సంక్షిప్త మార్గం ఇది.

## The problem Struct solves

```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)` కన్‌స్ట్రక్టర్, `attr_accessor`s కోసం `x` మరియు `y`, value-based equality, `to_s`, మరియు మరిన్నీ సహితంగా క్లాస్ జెనరేట్ చేస్తుంది — సరళమైన డేటా క్లాస్ యొక్క boilerplate కోడ్ ను తొలగిస్తుంది.

## Using a 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 సమానమైనవి — డేటా ఆబ్జెక్టల కోసం సౌకర్యవంతమైనవి), మరియు మీరు బ్లాక్‌లో కస్టమ్ మెథడ్‌లను జోడించవచ్చు.

## Keyword-initialized structs and 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 — విలువ ఆబ్జెక్టల కోసం అనువైనది ఆ అవుట్‌ను మార్చకూడదు.

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

`Struct` సరళమైన డేటా క్లాసులను **boilerplate లేకుండా త్వరగా సృష్టించడానికి** ఉపయోగకరమైన Ruby ఫీచర్ — కాబట్టి దానిని అర్థం చేసుకోవడం సంక్షిప్త, శుద్ధమైన Rubyని వ్రాయడానికి విలువైనది.

కోర్ ప్రయోజనం సరళమైన డేటా-హోల్డింగ్ క్లాస్‌కు అవసరమైన పునరావృత కోడ్‌ను తొలగించడం — సంపూర్ణ క్లాస్‌ను కన్‌స్ట్రక్టర్, `attr_accessor`s, మరియు equality తో వ్రాయడానికి బదులుగా, `Struct.new(:x, :y)` ఒక లైన్‌లో అన్నీ జెనరేట్ చేస్తుంది, **value-based equality** సహితంగా (సమానమైన attributesలను కలిగిన రెండు structs సమానమైనవి, ఇది డేటా ఆబ్జెక్టల కోసం మీరు కోరుకున్నది మరియు సాధారణ క్లాసుల reference equality నుండి భిన్నమైనది).

ఇది Struct నిండా weightless డేటా స్ట్రక్చర్‌ల కోసం, విలువ ఆబ్జెక్టల కోసం, మెథడ్‌ల నుండి సమూహీకరించిన విలువలను అందించడానికి, మరియు సరళమైన రికార్డ్‌ల కోసం ఎక్కడ సంపూర్ణ క్లాస్ అతిశయోక్తిగా ఉంటుందో — కోడ్‌ను సంక్షిప్తంగా ఉంచే ఆచరణాత్మక ఉత్పాదकత సాధనంగా ఉంది.

Struct (సంక్షిప్త డేటా క్లాసులు జెనరేట్ చేయబడిన accessors మరియు విలువ equality సహితం, ప్లస్ కస్టమ్ మెథడ్‌లను జోడించే సామర్థ్యం), keyword-initialized structs (అనేక ఫీల్డ్‌ల కోసం స్పష్టమైనది), మరియు ఆధునిక **`Data`** క్లాస్ (Ruby 3.2 యొక్క immutable విలువ ఆబ్జెక్టల ఆల్టర్నేటివ్ ఆ అవుట్‌ను మార్చకూడదు) అర్థం చేసుకోవడం సరళ డేటా మోడలింగ్ కోసం విలువైన జ్ఞానం.

చిన్న డేటా క్లాసులను నిర్వచించడం సాధారణ అవసరం కాబట్టి, మరియు Struct (మరియు Data) దానిని చేయడానికి సంక్షిప్త, idiomatic మార్గాన్ని ఉపయోగకరమైన జెనరేట్ చేయబడిన ప్రవర్తన (ముఖ్యంగా విలువ equality) సహితం అందిస్తారు కాబట్టి, Struct/Data కోసం సంపూర్ణ క్లాస్‌కు సంబంధించి ఎప్పుడు చేరాలో తెలుసుకోవడం ఆచరణాత్మక-సంబంధితమైన Ruby జ్ఞానం ఇది శుద్ధ, సంక్షిప్త కోడ్‌ను వ్రాయడం ప్రతిబింబిస్తుంది — సంబంధితమైన attributesలను lightweight టైప్‌లో కట్టడం యొక్క ఆసన్న కార్యకు Ruby డెవలపర్ యొక్క సాధనపెట్ట అందించిన ఉపయోగకరమైన సాధనం, Rubyలో conciseness మరియు boilerplate తగ్గించడం యొక్క నొక్కును ప్రతిబింబిస్తుంది.