X'inhu Struct u meta tuża?

Question

Accepted Answer

**`Struct`** hija klassi integrata ta' Ruby għal ħolqien mhir ta' klassijiet sempliċi li jgħaqqdu flimkien ftit **attributi** — jiġġeneraw il-konstruttore, l-accessors, l-ugwaljanza, u aktar awtomatikament. Hija mod konċiż biex tiddefinixxi klassijiet ta' dejta leggeri mingħajr iktebba klassi kompleta.

## Il-problema li Struct tissolva

```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)` jiġġenera klassi bi konstruttore, `attr_accessor`s għal `x` u `y`, ugwaljanza bbazata fuq il-valur, `to_s`, u aktar — u telimina l-boilerplate ta' klassi ta' dejta sempliċi.

## L-użu ta' 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 jipprovdu accessors u **ugwaljanza bbazata fuq il-valur** (żewġ structs b'attributi ugwali huma ugwali — konvenјenti għal oġġetti ta' dejta), u tista' żżid metodi customizzati fi blokk.

## Structs inizjalizzati b'keyword u 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
```

**`Data`** ta' Ruby 3.2 hija varjanta immutable ta' Struct — ideali għal value objects li m'għandhomx jinbidlu.

## Għaliex imorru

`Struct` hija feature utli ta' Ruby għal **ħolqien mhir ta' klassijiet ta' dejta sempliċi** mingħajr boilerplate, għalhekk il-fahim tagħha huwa valuruz għat-kitba ta' Ruby konċiż u nadif.

Il-benefiċċju ewlieni huwa l-eliminazzjoni tal-kodiċi ripetittiv li klassi sempliċi li żżomm dejta teħtieġ — minflok iktebba klassi kompleta bi konstruttore, `attr_accessor`s, u ugwaljanza, `Struct.new(:x, :y)` jiġġenera kollha ta' dak f'linja waħda, inklużi **ugwaljanza bbazata fuq il-valur** (żewġ structs b'attributi ugwali huma ugwali, li huwa dak li trid għal oġġetti ta' dejta u differenti mill-ugwaljanza ta' referenza tal-klassijiet regolari).

Dan jagħmel Struct ideali għal strutturi ta' dejta leggeri, value objects, il-ritorn ta' valuri gruppati minn metodi, u rekordi sempliċi fejn klassi kompleta tkun żejda — għodda prattika li żżid produttività li żżomm il-kodiċi konċiż.

il-fahim ta' Struct (klassijiet ta' dejta konċiża bi generated accessors u value equality, flimkien mal-abbiltà li żżid metodi customizzati), structs inizjalizzati b'keyword (aktar ċari għal ħafna fields), u l-klassi modernu **`Data`** (alternattiva immutable ta' Ruby 3.2 għal value objects li m'għandhomx jinbidlu) hija għarifa valuruzza.

Bħala li d-definizzjoni ta' klassijiet ta' dejta żgħar hija ħtieġa komuni, u billi Struct (u Data) jipprovdu mod konċiż u idiomatiku biex tagħmel dan b'ġarbu ta' dejta ġenerat utli (speċjalment value equality), il-fahim ta' meta tieħu lġinb Struct/Data kontra klassi kompleta huwa għarifa prattika ta' Ruby relevanti li rifless il-kitba ta' kodiċi nadif u konċiż — għodda utli fil-toolkit tal-iżviluppatur ta' Ruby għat-task frekwenti ta' bundling attributi relatati f'tip leggier, li jembodja l-enfasi ta' Ruby fuq il-konċizzjoni u r-riduzzjoni tal-boilerplate.