Hva er Struct og når bruker du det?

Question

Accepted Answer

**`Struct`** er en innebygd Ruby-klasse for raskt å lage enkle klasser som samler sammen noen få **attributter** — den genererer automatisk konstruktøren, accessorer, likhet, og mer. Det er en kortfattet måte å definere lette datklasser på uten å skrive en full klasse.

## Problemet 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`er for `x` og `y`, verdibasert likhet, `to_s`, og mer — og eliminerer dermed det repetitive koden fra en enkel datakasse.

## Bruk av 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 gir accessorer og **verdibasert likhet** (to structs med like attributter er like — praktisk for dataobjekter), og du kan legge til egendefinerte metoder i en blokk.

## Keyword-initialiserte 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.2s **`Data`** er en uforanderlig variant av Struct — ideell for verdiobjekter som ikke skal endres.

## Hvorfor det betyr noe

`Struct` er en nyttig Ruby-funksjon for **raskt å lage enkle datklasser** uten repetitiv kode, så det å forstå det er verdifullt for å skrive kortfattet, rein Ruby.

Hovednyttet er å eliminere den repetitive koden som en enkel datakasse krever — i stedet for å skrive en full klasse med en konstruktør, `attr_accessor`er, og likhet, genererer `Struct.new(:x, :y)` alt dette på én linje, inkludert **verdibasert likhet** (to structs med like attributter er like, som er det du vil for dataobjekter og som skiller seg fra vanlige klassers referanselikhet).

Dette gjør Struct ideell for lette datastrukturer, verdiobjekter, returnering av grupperte verdier fra metoder, og enkle poster der en full klasse ville være overkill — et praktisk produktivitetsverktøy som holder koden kortfattet.

Å forstå Struct (kortfattede datklasser med genererte accessorer og verdilikhet, pluss muligheten til å legge til egendefinerte metoder), keyword-initialiserte structs (klarere for mange felt), og den moderne **`Data`**-klassen (Rubys 3.2 uforanderlige alternativ for verdiobjekter som ikke skal endres) er verdifull kunnskap for å modellere enkle data elegant.

Siden det å definere små datklasser er et vanlig behov, og siden Struct (og Data) gir en kortfattet, idiomatisk måte å gjøre det på med nyttig generert oppførsel (spesielt verdilikhet), er det praktisk relevant Ruby-kunnskap å vite når du skal ta i bruk Struct/Data kontra en full klasse — det reflekterer det å skrive ren, kortfattet kode — et nyttig verktøy i Ruby-utvikleren sitt verktøykasse for den hyppige oppgaven å samle relaterte attributter i en lett type, som uttrykker Rubys vekt på kortfattethet og reduksjon av repetitiv kode.