Was ist Struct und wann wird es verwendet?

Question

Accepted Answer

**`Struct`** ist eine eingebaute Ruby-Klasse zum schnellen Erstellen einfacher Klassen, die einige **Attribute** zusammenbündeln — es generiert automatisch den Konstruktor, Accessoren, Gleichheit und vieles mehr. Es ist eine prägnante Möglichkeit, leichte Datenklassen zu definieren, ohne eine vollständige Klasse zu schreiben.

## Das Problem, das Struct löst

```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)` generiert eine Klasse mit einem Konstruktor, `attr_accessor`s für `x` und `y`, wertbasierter Gleichheit, `to_s` und mehr — wodurch der Boilerplate einer einfachen Datenklasse entfällt.

## Struct verwenden

```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 bieten Accessoren und **wertbasierte Gleichheit** (zwei Structs mit gleichen Attributen sind gleich — praktisch für Datenobjekte), und Sie können benutzerdefinierte Methoden in einem Block hinzufügen.

## Keyword-initialisierte Structs und 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.2s **`Data`** ist eine unveränderliche Variante von Struct — ideal für Wertobjekte, die sich nicht ändern sollten.

## Warum es wichtig ist

`Struct` ist eine nützliche Ruby-Funktion zum **schnellen Erstellen einfacher Datenklassen** ohne Boilerplate, daher ist das Verständnis dafür wertvoll für das Schreiben prägnanter, sauberer Ruby.

Der Kernvorteil ist das Vermeiden des sich wiederholenden Codes, den eine einfache Daten-haltende Klasse erfordert — statt eine vollständige Klasse mit Konstruktor, `attr_accessor`s und Gleichheit zu schreiben, generiert `Struct.new(:x, :y)` all das in einer Zeile, einschließlich **wertbasierter Gleichheit** (zwei Structs mit gleichen Attributen sind gleich, was Sie für Datenobjekte möchten und sich von der Referenzgleichheit regulärer Klassen unterscheidet).

Dies macht Struct ideal für leichte Datenstrukturen, Wertobjekte, das Zurückgeben gruppierter Werte aus Methoden und einfache Datensätze, bei denen eine vollständige Klasse übertrieben wäre — ein praktisches Produktivitätswerkzeug, das Code prägnant hält.

Das Verständnis von Struct (prägnante Datenklassen mit generierten Accessoren und Wertequalität sowie die Möglichkeit, benutzerdefinierte Methoden hinzuzufügen), keyword-initialisierten Structs (klarer für viele Felder) und der modernen **`Data`**-Klasse (Rubys 3.2 unveränderliche Alternative für Wertobjekte, die sich nicht ändern sollten) ist wertvoll Wissen zur eleganten Modellierung einfacher Daten.

Da die Definition kleiner Datenklassen ein häufiges Bedürfnis ist und Struct (und Data) eine prägnante, idiomatische Methode dazu bieten mit nützlichem generiertem Verhalten (besonders Wertequalität), ist das Wissen, wann man zu Struct/Data greifen soll versus eine vollständige Klasse, praktisch relevantes Ruby-Wissen, das saubere, prägnante Code widerspiegelt — ein nützliches Werkzeug im Toolkit des Ruby-Entwicklers für die häufige Aufgabe, verwandte Attribute in einen leichten Typ zu bündeln, das Rubys Betonung auf Prägnanz und Reduzierung von Boilerplate verkörpernd.