Struct is een ingebouwde Ruby-klasse om snel eenvoudige klassen te maken die enkele attributen bundelen — en genereert automatisch de constructor, accessors, gelijkheid, en meer. Het is een beknopte manier om lichte dataklassen te definiëren zonder een volledige klasse te schrijven.
,
()
= x
= y
()
x == other.x && y == other.y
= .new(, )
Struct.new(:x, :y) genereert een klasse met een constructor, attr_accessors voor x en y, op waarde gebaseerde gelijkheid, to_s, en meer — waardoor de boilerplate van een eenvoudige dataklasse wegvalt.
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 bieden accessors en op waarde gebaseerde gelijkheid (twee structs met gelijke attributen zijn gelijk — handig voor dataobjecten), en je kunt aangepaste methoden toevoegen in een blok.
# 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 is een immutable variant van Struct — ideaal voor waarde-objecten die niet moeten veranderen.
Struct is een handig Ruby-feature om snel eenvoudige dataklassen te maken zonder boilerplate, dus het begrijpen ervan is waardevol voor het schrijven van beknopte, schone Ruby.
De kernbaat is het elimineren van repetitieve code die een eenvoudige dataklasse vereist — in plaats van een volledige klasse te schrijven met een constructor, attr_accessors, en gelijkheid, genereert Struct.new(:x, :y) alles in één regel, inclusief op waarde gebaseerde gelijkheid (twee structs met gelijke attributen zijn gelijk, wat je wilt voor dataobjecten en verschilt van reguliere klassen' referentiegelijkheid).
Dit maakt Struct ideaal voor lichte datastructuren, waarde-objecten, het retourneren van gegroepeerde waarden uit methoden, en eenvoudige records waar een volledige klasse overkill zou zijn — een praktisch productiviteitstool die code beknopt houdt.
Het begrijpen van Struct (beknopte dataklassen met gegenereerde accessors en waardeequivalentie, plus de mogelijkheid om aangepaste methoden toe te voegen), keyword-geïnitialiseerde structs (duidelijker voor veel velden), en de moderne Data-klasse (Ruby 3.2's immutable alternatief voor waarde-objecten die niet moeten veranderen) is waardevolle kennis voor het elegant modelleren van eenvoudige data.
Omdat het definiëren van kleine dataklassen een veelvoorkomende behoefte is, en omdat Struct (en Data) een beknopte, idiomatische manier bieden om dit te doen met nuttig gegenereerd gedrag (vooral waardeequivalentie), is het praktisch relevant Ruby-kennis om te weten wanneer je naar Struct/Data of een volledige klasse grijpt — een nuttig tool in de Ruby-ontwikkelaar's toolkit voor de veel voorkomende taak van het bundelen van gerelateerde attributen in een licht type, dat Ruby's nadruk op beknoptheid en het verminderen van boilerplate belichaamt.