Hvad er Struct, og hvornår bruger du det?

Question

Accepted Answer

**`Struct`** er en indbygget Ruby-klasse til hurtigt at skabe simple klasser, der bundter nogle få **attributter** sammen — og genererer automatisk konstruktøren, accessorer, lighed og meget mere. Det er en kortfattet måde at definere lette dataklasser på uden at skulle skrive en fuld klasse.

## Problemet som Struct løser

```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)` genererer en klasse med en konstruktør, `attr_accessor`s for `x` og `y`, værdibaseret lighed, `to_s` og mere — og eliminerer dermed boilerplate-koden for en simpel dataklasse.

## Brug af en 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 giver accessorer og **værdibaseret lighed** (to structs med lige attributter er ens — praktisk for dataobjekter), og du kan tilføje custom-metoder i en blok.

## Keyword-initialiserede structs og 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's **`Data`** er en immutable variant af Struct — ideel til værdi-objekter, der ikke skal ændres.

## Hvorfor det betyder noget

`Struct` er en brugbar Ruby-feature til **hurtigt at skabe simple dataklasser** uden boilerplate, så forståelsen af det er værdifuld for at skrive kortfattet, rent Ruby.

Kernfordelen er at eliminere den repetitive kode, som en simpel data-holdende klasse kræver — i stedet for at skrive en fuld klasse med en konstruktør, `attr_accessor`s og lighed, genererer `Struct.new(:x, :y)` alt dette på én linje, inklusive **værdibaseret lighed** (to structs med lige attributter er ens, hvilket er det, du ønsker for dataobjekter, og som adskiller sig fra regulære klassers reference-lighed).

Dette gør Struct ideel til lette datastrukturer, værdi-objekter, returnering af grupperede værdier fra metoder og simple records, hvor en fuld klasse ville være overkill — et praktisk produktivitetsværktøj, der holder koden kortfattet.

Forståelse af Struct (kortfattede dataklasser med genererede accessorer og værdi-lighed, plus muligheden for at tilføje custom-metoder), keyword-initialiserede structs (tydeligere for mange felter) og den moderne **`Data`**-klasse (Ruby 3.2's immutable alternativ til værdi-objekter, der ikke må ændres) er værdifuld viden til elegant modellering af simple data.

Da definitionen af små dataklasser er et hyppigt behov, og da Struct (og Data) giver en kortfattet, idiomatisk måde at gøre det på med brugbar genereret opførsel (især værdi-lighed), er kendskab til hvornår man skal vælge Struct/Data i forhold til en fuld klasse praktisk relevant Ruby-viden, som afspejler skrivning af rent, kortfattet kode — et brugbart værktøj i Ruby-udviklerens værktøjskasse til den hyppige opgave at bundtere relaterede attributter i en let type, som embodier Rubys vægt på kortfattethed og reducering af boilerplate.