რა არის Struct და როდის გამოიყენებ მას?

Question

Accepted Answer

**`Struct`** არის Ruby-ის ჩაშენებული კლასი, რომელიც საშუალებას იძლევა სწრაფად შექმნა მარტივი კლასები, რომლებიც აერთებენ რამდენიმე **attributes**-ს — ავტომატურად აგენერირებს კონსტრუქტორს, accessors-ებს, equality-ს და ა.შ. ეს არის მარტივი საშუალება, რომელიც განსაზღვრავს მსუბუქი data classes-ებს სრული კლასის დაწერის გარეშე.

## პრობლემა, რომელსაც 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)` აგენერირებს კლასს კონსტრუქტორით, `attr_accessor`-ებით `x`-ისა და `y`-ის, value-based equality-ით, `to_s`-ით და კიდევ მრავალი სხვა რამით — აღმოფხვრის უბრალო 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-ში.

## 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 სწრაფი შექმნისთვის მარტივი data classes-ების boilerplate-კოდის გარეშე, ამიტომ მისი გაგება ღირებულია concise, clean Ruby-ის დაწერისთვის.

ძირითადი სარგებელი არის განმეორებითი კოდის აღმოფხვრა, რომელსაც მოითხოვს მარტივი data-holding class — სრული კლასის დაწერის ნაცვლად კონსტრუქტორით, `attr_accessor`-ებით და equality-თ, `Struct.new(:x, :y)` აგენერირებს ყველა ამას ერთ ხაზში, თუნდაც **value-based equality** (ორი structs-ი ტოლი attributes-ებით ტოლია, რაც თქვენ გინდათ data objects-ებისთვის და განსხვავდება regular classes-ის reference equality-სგან).

ეს უკეთეს აკეთებს Struct-ს მსუბუქი data structures-ებისთვის, value objects-ებისთვის, grouped values-ის დაბრუნებისთვის მეთოდებიდან, და მარტივი records-ებისთვის სადაც სრული კლასი excess იქნებოდა — პრაქტიკული productivity tool, რომელიც უშუაებს კოდს concise-ს.

Struct-ის გაგება (concise data classes-ი შექმნილი accessors-ებით და value equality-თ, პლუს შესაძლებლობა დაამატო აკრეფილი მეთოდები), keyword-initialized structs-ი (უფრო ჯაბრი ბევრი fields-ის შემთხვევაში), და თანამედროვე **`Data`** class (Ruby 3.2-ის immutable alternative value objects-ებისთვის, რომლებიც არ უნდა შეიცვალოთ) არის ღირებული ცოდნა მარტივი data-ს ელეგანტურად მოდელირებისთვის.

მცირე data classes-ების განსაზღვრა არის ხშირი საჭიროება, და რადგან Struct (და Data) იძლევა concise, idiomatic საშუალებას მისი გასაკეთებლად სასარგებლო აგენერირებული behavior-ით (განსაკუთრებით value equality), იცოდეთ როდის გამოიყენოთ Struct/Data versus სრული class არის პრაქტიკულად-შესაბამი Ruby ცოდნა, რომელიც არეკლავს clean, concise კოდის დაწერას — სასარგებლო tool Ruby developer-ის toolbox-ში ხშირი ამოცანისთვის გაკავშირებული attributes-ის მსუბუქ type-ში დაჯამება, რომელიც გამოხატავს Ruby-ის emphasis-ს conciseness-ზე და boilerplate-ის შემცირებაზე.