Što je Struct i kada ga koristiš?

Question

Accepted Answer

**`Struct`** je ugrađena Ruby klasa za brzo stvaranje jednostavnih klasa koje grupiraju nekoliko **atributa** — automatski generirajući konstruktor, accessore, jednakost i više toga. To je sažet način za definiranje laganих klasа za podatke bez pisanja pune klase.

## Problem koji Struct rješava

```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)` generiše klasu s konstruktorom, `attr_accessor`ima za `x` i `y`, jednakosti temeljenom na vrijednostima, `to_s` i više — eliminirajući boilerplate jednostavne klase za podatke.

## Korištenje Structa

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

Structovi pružaju accessore i **jednakost temeljenu na vrijednostima** (dva structa s jednakim atributima su jednaki — praktično za objekte podataka), i možeš dodati prilagođene metode u blok.

## Strukturirani keyword inicijalizatori i 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
```

Rubyev **`Data`** iz verzije 3.2 je nepromjenjiva varijanta Structa — idealna za objekte vrijednosti koji se ne bi trebali promijeniti.

## Zašto je to važno

`Struct` je korisna Ruby značajka za **brzo stvaranje jednostavnih klasa za podatke** bez boilerplaatea, pa je razumijevanje toga vrijedno za pisanje sažetog, čistog Rubyja.

Osnovnog koristi je eliminiranje repetitivnog koda koji zahtijeva jednostavna klasa za podatke — umjesto pisanja pune klase s konstruktorom, `attr_accessor`ima i jednakosti, `Struct.new(:x, :y)` generiše sve to u jednoj liniji, uključujući **jednakost temeljenu na vrijednostima** (dva structa s jednakim atributima su jednaki, što je ono što trebaš za objekte podataka i razlikuje se od referentne jednakosti običnih klasa).

Ovo čini Struct idealnim za lagane strukture podataka, objekte vrijednosti, vraćanje grupirane vrijednosti iz metoda i jednostavne zapise gdje bi puna klasa bila previše — praktičan alat za produktivnost koji čuva kod sažetim.

Razumijevanje Structa (sažete klase za podatke s generiranim accesorima i vrijednosnom jednakosti, plus mogućnost dodavanja prilagođenih metoda), ključnih inicijaliziranih structova (jasniji za mnoga polja) i moderne **`Data`** klase (Rubyeva nepromijenljiva alternativa iz verzije 3.2 za objekte vrijednosti koji se ne bi trebali promijeniti) je vrijedno znanje za elegantno modeliranje jednostavnih podataka.

Budući da je definiranje malih klasa za podatke česta potreba, i budući da Struct (i Data) pružaju sažet, idiomatski način da se to učini s korisnim generiranim ponašanjem (posebno vrijednosnom jednakosti), znanje kada posegnuti za Structom/Datom nasuprot pune klase je praktično relevantno Ruby znanje koje odražava pisanje čistog, sažetog koda — koristan alat u Ruby programerovoj alatnici za čest zadatak bundliranja povezanih atributa u laganu tipsku, воплоћујући Rubyjev naglasak na sažetosti i smanjenju boilerplaatea.