Struct એ Ruby માં બનેલી ક્લાસ છે જે કેટલીક attributes ને એક જગ્યાએ બાંધવા માટે સરળ ક્લાસ બનાવે છે — constructor, accessors, equality, અને વધુ આપોઆપ જનરેટ કરે છે. તે સંપૂર્ણ ક્લાસ લખ્યા વિના હળવા ડેટા ક્લાસીસ વ્યાખ્યાયિત કરવાનો સંક્ષિપ્ત રસ્તો છે.
,
()
= x
= y
()
x == other.x && y == other.y
= .new(, )
Struct.new(:x, :y) એક ક્લાસ જનરેટ કરે છે જેમાં constructor, x અને y માટે attr_accessors, value-based equality, to_s, અને વધુ છે — સરળ ડેટા ક્લાસના બોઇલરપ્લેટને દૂર કરે છે.
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 accessors અને value-based equality પ્રદાન કરે છે (બે structs સમાન attributes સાથે સમાન છે — ડેટા ઑબ્જેક્ટ્સ માટે અનુકૂળ), અને તમે બ્લૉક માં custom methods ઉમેરી શકો છો.
# 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 નો Data એ Struct નું immutable variant છે — મૂલ્ય ઑબ્જેક્ટ્સ માટે આદર્શ જે બદલાશે નહીં.
Struct એ Ruby માટે ઉપયોગી feature છે જે બોઇલરપ્લેટ વિના સરળ ડેટા ક્લાસીસ ઝડપથી બનાવે છે, તેથી તેને સમજવું concise, clean Ruby લખવા માટે મૂલ્યવાન છે.
મૂળ લાભ એ છે કે સરળ ડેટા-holding ક્લાસ માટે જરૂરી પુનરાવર્તિત code દૂર કરવો — સંપૂર્ણ ક્લાસ સાથે constructor, attr_accessors, અને equality લખવાને બદલે, Struct.new(:x, :y) એક લાઈનમાં તે બધું જનરેટ કરે છે, જેમાં value-based equality પણ છે (બે structs સમાન attributes સાથે સમાન છે, જે ડેટા ઑબ્જેક્ટ્સ માટે જોઇતું છે અને નિયમિત ક્લાસીસની reference equality થી અલગ છે).
હજુ data structures, મૂલ્ય ઑબ્જેક્ટ્સ, methods માંથી grouped values રીટર્ન કરવા, અને સરળ records માટે આદર્શ છે જ્યાં સંપૂર્ણ ક્લાસ બધું જ હોય — એક પ્રાયોગિક productivity tool જે code ને concise રાખે છે.
Struct ને સમજવું (concise data classes generated accessors અને value equality સાથે, ઉપરાંત custom methods ઉમેરવાની ક્ષમતા), keyword-initialized structs (ઘણા fields માટે સ્પષ્ટ), અને આધુનિક Data ક્લાસ (Ruby 3.2 નો immutable alternative મૂલ્ય ઑબ્જેક્ટ્સ માટે જે બદલાશે નહીં) એ મૂલ્યવાન જ્ઞાન છે સરળ ડેટા elegantly model કરવા માટે.
છોટી ડેટા ક્લાસીસ વ્યાખ્યાયિત કરવી એક સામાન્ય જરૂર છે, અને Struct (અને Data) તેને concise, idiomatic રીતે કરવા માટે ઉપયોગી generated behavior સાથે પ્રદાન કરે છે (ખાસ કરીને value equality), તેથી ક્યારે Struct/Data માટે પહોંચવું તે વર્સ સ vs સંપૂર્ણ ક્લાસ એ practically-relevant Ruby જ્ઞાન છે જે clean, concise code લખવા માટે પ્રતિબિંબિત કરે છે — Ruby developer ના toolkit માં useful tool સંબંધિત attributes ને lightweight type માં બાંધવાના વારંવાર કામ માટે, Ruby ની conciseness અને boilerplate ઘટાડવા પર ભાર મૂકે છે.