Struct क्या है और आप इसका उपयोग कब करते हैं?

Question

Accepted Answer

**`Struct`** Ruby की एक built-in class है जो कुछ **attributes** को एक साथ bundle करने वाली simple classes को जल्दी बनाने के लिए है — constructor, accessors, equality, और बहुत कुछ automatically generate करती है। यह एक पूर्ण class लिखे बिना lightweight data classes को define करने का एक concise तरीका है।

## Struct जिस problem को हल करता है

```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`, और बहुत कुछ के साथ एक class generate करता है — एक simple data class का 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** प्रदान करते हैं (दो structs जिनके attributes बराबर हैं वे बराबर हैं — data objects के लिए सुविधाजनक), और आप एक block में 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` एक उपयोगी Ruby feature है जो **boilerplate के बिना simple data classes को जल्दी बनाने** के लिए है, इसलिए इसे समझना concise, clean Ruby लिखने के लिए मूल्यवान है।

Core benefit उस दोहराव वाले code को समाप्त करना है जो एक simple data-holding class को चाहिए — एक constructor, `attr_accessor`s, और equality के साथ एक पूर्ण class लिखने के बजाय, `Struct.new(:x, :y)` यह सब एक line में generate करता है, जिसमें **value-based equality** भी शामिल है (दो structs जिनके attributes बराबर हैं वे बराबर हैं, जो data objects के लिए आप चाहते हैं और regular classes की reference equality से अलग है)।

यह Struct को lightweight data structures, value objects, methods से grouped values return करने, और simple records के लिए आदर्श बनाता है जहाँ एक पूर्ण class overkill होगी — एक practical productivity tool जो code को concise रखता है।

Struct (generated accessors और value equality के साथ concise data classes, साथ ही custom methods जोड़ने की क्षमता), keyword-initialized structs (कई fields के लिए स्पष्ट), और modern **`Data`** class (Ruby 3.2 का immutable alternative value objects के लिए जो बदलना नहीं चाहिए) को समझना simple data को elegantly model करने के लिए मूल्यवान ज्ञान है।

चूँकि small data classes को define करना एक common आवश्यकता है, और चूँकि Struct (और Data) उपयोगी generated behavior (विशेष रूप से value equality) के साथ इसे करने का एक concise, idiomatic तरीका प्रदान करते हैं, यह जानना कि एक पूर्ण class बनाम Struct/Data के लिए कब पहुँचें, practically relevant Ruby ज्ञान है जो clean, concise code लिखने को दर्शाता है — related attributes को एक lightweight type में bundle करने के frequent task के लिए Ruby developer के toolkit में एक उपयोगी tool, जो Ruby के conciseness और boilerplate को कम करने पर जोर को मूर्त रूप देता है।