Struct est une classe Ruby intégrée pour créer rapidement des classes simples qui regroupent quelques attributs — générant automatiquement le constructeur, les accesseurs, l'égalité, et plus encore. C'est une façon concise de définir des classes de données légères sans écrire une classe complète.
,
()
= x
= y
()
x == other.x && y == other.y
= .new(, )
Struct.new(:x, :y) génère une classe avec un constructeur, des attr_accessors pour x et y, une égalité basée sur les valeurs, to_s, et plus encore — éliminant la redondance d'une simple classe de données.
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
Les Structs fournissent des accesseurs et une égalité basée sur les valeurs (deux structs avec des attributs égaux sont égales — pratique pour les objets de données), et vous pouvez ajouter des méthodes personnalisées dans un bloc.
# 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
La Data de Ruby 3.2 est une variante immuable de Struct — idéale pour les objets de valeur qui ne doivent pas changer.
Struct est une fonctionnalité Ruby utile pour créer rapidement des classes de données simples sans redondance, donc la comprendre est précieux pour écrire du Ruby concis et propre.
L'avantage principal est d'éliminer le code répétitif qu'une simple classe de données nécessite — au lieu d'écrire une classe complète avec un constructeur, des attr_accessors et l'égalité, Struct.new(:x, :y) génère tout cela en une seule ligne, y compris une égalité basée sur les valeurs (deux structs avec des attributs égaux sont égales, ce qu'on veut pour les objets de données et qui diffère de l'égalité par référence des classes ordinaires).
Cela rend Struct idéale pour les structures de données légères, les objets de valeur, retourner des valeurs groupées des méthodes, et les simples enregistrements où une classe complète serait excessif — un outil de productivité pratique qui garde le code concis.
Comprendre Struct (classes de données concises avec des accesseurs générés et l'égalité des valeurs, plus la capacité d'ajouter des méthodes personnalisées), les structs initialisées par mots-clés (plus claires pour de nombreux champs), et la classe Data moderne (alternative immuable de Ruby 3.2 pour les objets de valeur qui ne doivent pas changer) est une connaissance précieuse pour modéliser les données simples élégamment.
Puisque la définition de petites classes de données est un besoin courant, et puisque Struct (et Data) fournissent une façon concise et idiomatique de le faire avec un comportement généré utile (notamment l'égalité des valeurs), savoir quand avoir recours à Struct/Data par rapport à une classe complète est une connaissance Ruby pertinente en pratique qui reflète l'écriture de code propre et concis — un outil utile dans la boîte à outils du développeur Ruby pour la tâche fréquente de regrouper des attributs connexes dans un type léger, incarnant l'accent de Ruby sur la concision et la réduction de la redondance.