Co je to Struct a kdy ho používáte?

Question

Accepted Answer

**`Struct`** je vestavěná Ruby třída pro rychlé vytváření jednoduchých tříd, které seskupují několik **atributů** — automaticky generují konstruktor, accessory, rovnost a další funkce. Je to stručný způsob, jak definovat lehké datové třídy bez psaní úplné třídy.

## Problém, který Struct řeší

```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)` generuje třídu s konstruktorem, `attr_accessor`y pro `x` a `y`, rovností na základě hodnot, `to_s` a další funkce — eliminuje standardní kód jednoduché datové třídy.

## Používání 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
```

Structy poskytují accessory a **rovnost na základě hodnot** (dva structy se stejnými atributy jsou si rovny — pohodlné pro datové objekty), a můžete přidávat vlastní metody v bloku.

## Keyword-initialized structy a 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
```

**`Data`** z Ruby 3.2 je neměnná varianta Structu — ideální pro value objekty, které by se neměly měnit.

## Proč je to důležité

`Struct` je užitečná Ruby funkce pro **rychlé vytváření jednoduchých datových tříd** bez standardního kódu, takže jeho pochopení je cenné pro psaní stručného a čistého Ruby.

Hlavní výhodou je eliminace opakujícího se kódu, který vyžaduje jednoduchá třída uchovávající data — místo psaní úplné třídy s konstruktorem, `attr_accessor`y a rovností, `Struct.new(:x, :y)` generuje vše v jednom řádku, včetně **rovnosti na základě hodnot** (dva structy se stejnými atributy jsou si rovny, což je to, co chcete pro datové objekty a liší se od referenční rovnosti běžných tříd).

Toto dělá Struct ideálním pro lehké datové struktury, value objekty, vracení seskupených hodnot z metod a jednoduché záznamy, kde by úplná třída byla zbytečná — praktický nástroj produktivity, který udržuje kód stručný.

Pochopení Structu (stručné datové třídy s generovanými accessory a hodnotovou rovností, plus možnost přidávat vlastní metody), keyword-initialized structů (jasnější pro mnoho polí) a moderní třídy **`Data`** (Ruby 3.2 neměnná alternativa pro value objekty, které by se neměly měnit) je cenné vědění pro elegantní modelování jednoduchých dat.

Protoře definování malých datových tříd je běžná potřeba, a protože Struct (a Data) poskytují stručný, idiomatický způsob, jak to udělat s užitečným generovaným chováním (zvláště hodnotová rovnost), vědět, kdy sáhnout po Structu/Data versus po úplné třídě, je prakticky relevantní Ruby znalost, která odráží psaní čistého, stručného kódu — užitečný nástroj v arzenálu Ruby vývojáře pro časté seskupování souvisejících atributů do lehkého typu, které ztělesňuje Ruby důraz na stručnost a snížení standardního kódu.